ConcurrentFlatBitSetFrame (OpenHFT/Chronicle-Algorithms 2.23ea0 API)

java.lang.Object
- net.openhft.chronicle.algo.bitset.ConcurrentFlatBitSetFrame

All Implemented Interfaces:

BitSetFrame
```
public final class ConcurrentFlatBitSetFrame
extends Object
implements BitSetFrame
```
DirectBitSet with input validations and ThreadSafe memory access.

Nested Class Summary
- Nested classes/interfaces inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame
  BitSetFrame.Bits

Field Summary
- Fields inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame
  NOT_FOUND

Constructor Summary

Constructors
Constructor and Description

ConcurrentFlatBitSetFrame(long logicalSize)

Constructors
Constructor and Description
`ConcurrentFlatBitSetFrame(long logicalSize)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BitSetAlgorithm`	`algorithm()`
`<T> long`	`cardinality(Access<T> access, T handle, long offset)` Returns the number of bits set to `true` in the bit set.
`<T> void`	`clear(Access<T> access, T handle, long offset, long bitIndex)` Sets the bit specified by the index to `false`.
`<T> void`	`clearAll(Access<T> access, T handle, long offset)` Equivalent to `clearRange(0, logicalSize())`.
`<T> boolean`	`clearIfSet(Access<T> access, T handle, long offset, long bitIndex)` Clears the bit at the specified index (sets it to `false`).
`<T> long`	`clearNextNContinuousSetBits(Access<T> access, T handle, long offset, long fromIndex, int numberOfBits)` WARNING! This implementation doesn't strictly follow the contract from `BitSetFrame` interface.
`<T> long`	`clearNextSetBit(Access<T> access, T handle, long offset, long fromIndex)` Finds and clears the first bit that is set to `true` that occurs on or after the specified starting index.
`<T> long`	`clearPreviousNContinuousSetBits(Access<T> access, T handle, long offset, long fromIndex, int numberOfBits)` WARNING! This implementation doesn't strictly follow the contract from `DirectBitSet` interface.
`<T> long`	`clearPreviousSetBit(Access<T> access, T handle, long offset, long fromIndex)` Finds and clears the nearest bit that is set to `true` that occurs on or before the specified starting index.
`<T> void`	`clearRange(Access<T> access, T handle, long offset, long fromIndex, long exclusiveToIndex)` Sets the bits from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to `false`.
`<T> void`	`flip(Access<T> access, T handle, long offset, long bitIndex)` Sets the bit at the specified index to the complement of its current value.
`<T> void`	`flipRange(Access<T> access, T handle, long offset, long fromIndex, long exclusiveToIndex)` Sets each bit from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to the complement of its current value.
`<T> boolean`	`get(Access<T> access, T handle, long offset, long bitIndex)` Returns the value of the bit with the specified index.
`<T> boolean`	`isRangeClear(Access<T> access, T handle, long offset, long fromIndex, long toIndex)` Checks if each bit from the specified `fromIndex` (inclusive) to the specified `exclusiveToIndex` is set to `false`.
`<T> boolean`	`isRangeSet(Access<T> access, T handle, long offset, long fromIndex, long toIndex)` Checks if each bit from the specified `fromIndex` (inclusive) to the specified `exclusiveToIndex` is set to `true`.
`long`	`logicalSize()` Number of bits in this frame.
`<T> long`	`nextClearBit(Access<T> access, T handle, long offset, long fromIndex)` Returns the index of the first bit that is set to `false` that occurs on or after the specified starting index.
`<T> long`	`nextSetBit(Access<T> access, T handle, long offset, long fromIndex)` Returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.
`<T> long`	`previousClearBit(Access<T> access, T handle, long offset, long fromIndex)` Returns the index of the nearest bit that is set to `false` that occurs on or before the specified starting index.
`<T> long`	`previousSetBit(Access<T> access, T handle, long offset, long fromIndex)` Returns the index of the nearest bit that is set to `true` that occurs on or before the specified starting index.
`<T> void`	`set(Access<T> access, T handle, long offset, long bitIndex)` Sets the bit at the specified index to `true`.
`<T> void`	`setAll(Access<T> access, T handle, long offset)` Equivalent to `setRange(0, logicalSize())`.
`BitSetFrame.Bits`	`setBits()` Returns an iteration of set bits in direct order (from 0 to the end of the bit set).
`<T> boolean`	`setIfClear(Access<T> access, T handle, long offset, long bitIndex)` Sets the bit at the specified index to `true`.
`<T> long`	`setNextClearBit(Access<T> access, T handle, long offset, long fromIndex)` Finds and sets to `true` the first bit that is set to `false` that occurs on or after the specified starting index.
`<T> long`	`setNextNContinuousClearBits(Access<T> access, T handle, long offset, long fromIndex, int numberOfBits)` WARNING! This implementation doesn't strictly follow the contract from `DirectBitSet` interface.
`<T> long`	`setPreviousClearBit(Access<T> access, T handle, long offset, long fromIndex)` Finds and sets to `true` the nearest bit that is set to `false` that occurs on or before the specified starting index.
`<T> long`	`setPreviousNContinuousClearBits(Access<T> access, T handle, long offset, long fromIndex, int numberOfBits)` WARNING! This implementation doesn't strictly follow the contract from `DirectBitSet` interface.
`<T> void`	`setRange(Access<T> access, T handle, long offset, long fromIndex, long exclusiveToIndex)` Sets the bits from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to `true`.
`long`	`sizeInBytes()` Number of bytes taken by this frame.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame
isClear, isSet, set, setRange

- Constructor Detail
  - ConcurrentFlatBitSetFrame
```
public ConcurrentFlatBitSetFrame(long logicalSize)
```
- Method Detail
  - flip
```
public <T> void flip(Access<T> access,
                     T handle,
                     long offset,
                     long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bit at the specified index to the complement of its current value.
    
    Specified by:
    
    flip in interface BitSetFrame
    
    bitIndex - the index of the bit to flip
  - flipRange
```
public <T> void flipRange(Access<T> access,
                          T handle,
                          long offset,
                          long fromIndex,
                          long exclusiveToIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets each bit from the specified fromIndex (inclusive) to the specified toIndex (exclusive) to the complement of its current value.
    
    Specified by:
    
    flipRange in interface BitSetFrame
    
    fromIndex - index of the first bit to flip
    
    exclusiveToIndex - index after the last bit to flip
  - set
```
public <T> void set(Access<T> access,
                    T handle,
                    long offset,
                    long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bit at the specified index to true.
    
    Specified by:
    
    set in interface BitSetFrame
    
    bitIndex - the bit index
  - setIfClear
```
public <T> boolean setIfClear(Access<T> access,
                              T handle,
                              long offset,
                              long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bit at the specified index to true.
    
    Specified by:
    
    setIfClear in interface BitSetFrame
    
    bitIndex - the bit index
    
    Returns:
    
    true if the bit was zeroOut, or false if the bit was already set
  - setRange
```
public <T> void setRange(Access<T> access,
                         T handle,
                         long offset,
                         long fromIndex,
                         long exclusiveToIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bits from the specified fromIndex (inclusive) to the specified toIndex (exclusive) to true.
    
    Specified by:
    
    setRange in interface BitSetFrame
    
    fromIndex - index of the first bit to be set
    
    exclusiveToIndex - index after the last bit to be set
  - setAll
```
public <T> void setAll(Access<T> access,
                       T handle,
                       long offset)
```
    Description copied from interface: BitSetFrame
    
    Equivalent to setRange(0, logicalSize()).
    
    Specified by:
    
    setAll in interface BitSetFrame
  - clear
```
public <T> void clear(Access<T> access,
                      T handle,
                      long offset,
                      long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bit specified by the index to false.
    
    Specified by:
    
    clear in interface BitSetFrame
    
    bitIndex - the index of the bit to be cleared
  - clearIfSet
```
public <T> boolean clearIfSet(Access<T> access,
                              T handle,
                              long offset,
                              long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Clears the bit at the specified index (sets it to false).
    
    Specified by:
    
    clearIfSet in interface BitSetFrame
    
    bitIndex - a bit index
    
    Returns:
    
    the previous value of the bit at the specified index
  - clearRange
```
public <T> void clearRange(Access<T> access,
                           T handle,
                           long offset,
                           long fromIndex,
                           long exclusiveToIndex)
```
    Description copied from interface: BitSetFrame
    
    Sets the bits from the specified fromIndex (inclusive) to the specified toIndex (exclusive) to false.
    
    Specified by:
    
    clearRange in interface BitSetFrame
    
    fromIndex - index of the first bit to be cleared
    
    exclusiveToIndex - index after the last bit to be cleared
  - clearAll
```
public <T> void clearAll(Access<T> access,
                         T handle,
                         long offset)
```
    Description copied from interface: BitSetFrame
    
    Equivalent to clearRange(0, logicalSize()).
    
    Specified by:
    
    clearAll in interface BitSetFrame
  - get
```
public <T> boolean get(Access<T> access,
                       T handle,
                       long offset,
                       long bitIndex)
```
    Description copied from interface: BitSetFrame
    
    Returns the value of the bit with the specified index. The value is true if the bit with the index bitIndex is currently set in this DirectBitSet; otherwise, the result is false.
    
    Specified by:
    
    get in interface BitSetFrame
    
    bitIndex - the bit index
    
    Returns:
    
    the value of the bit with the specified index
  - isRangeSet
```
public <T> boolean isRangeSet(Access<T> access,
                              T handle,
                              long offset,
                              long fromIndex,
                              long toIndex)
```
    Description copied from interface: BitSetFrame
    
    Checks if each bit from the specified fromIndex (inclusive) to the specified exclusiveToIndex is set to true.
    
    Specified by:
    
    isRangeSet in interface BitSetFrame
    
    fromIndex - index of the first bit to check
    
    toIndex - index after the last bit to check
    
    Returns:
    
    true if all bits in the specified range are set to true, false otherwise
  - isRangeClear
```
public <T> boolean isRangeClear(Access<T> access,
                                T handle,
                                long offset,
                                long fromIndex,
                                long toIndex)
```
    Description copied from interface: BitSetFrame
    
    Checks if each bit from the specified fromIndex (inclusive) to the specified exclusiveToIndex is set to false.
    
    Specified by:
    
    isRangeClear in interface BitSetFrame
    
    fromIndex - index of the first bit to check
    
    toIndex - index after the last bit to check
    
    Returns:
    
    true if all bits in the specified range are set to false, false otherwise
  - nextSetBit
```
public <T> long nextSetBit(Access<T> access,
                           T handle,
                           long offset,
                           long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Returns the index of the first bit that is set to true that occurs on or after the specified starting index. If no such bit exists then -1 is returned.
    
    Specified by:
    
    nextSetBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the next set bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.clearNextSetBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - setBits
```
public BitSetFrame.Bits setBits()
```
    Description copied from interface: BitSetFrame
    
    Returns an iteration of set bits in direct order (from 0 to the end of the bit set).
    
    Specified by:
    
    setBits in interface BitSetFrame
    
    Returns:
    
    an iteration of set bits in direct order
  - algorithm
```
public BitSetAlgorithm algorithm()
```
    Specified by:
    
    algorithm in interface BitSetFrame
  - clearNextSetBit
```
public <T> long clearNextSetBit(Access<T> access,
                                T handle,
                                long offset,
                                long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Finds and clears the first bit that is set to true that occurs on or after the specified starting index. If no such bit exists then -1 is returned.
    
    Specified by:
    
    clearNextSetBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the next set bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.nextSetBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - nextClearBit
```
public <T> long nextClearBit(Access<T> access,
                             T handle,
                             long offset,
                             long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Returns the index of the first bit that is set to false that occurs on or after the specified starting index. If no such bit exists then -1 is returned.
    
    Specified by:
    
    nextClearBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the next zeroOut bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.setNextClearBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - setNextClearBit
```
public <T> long setNextClearBit(Access<T> access,
                                T handle,
                                long offset,
                                long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Finds and sets to true the first bit that is set to false that occurs on or after the specified starting index. If no such bit exists then -1 is returned.
    
    Specified by:
    
    setNextClearBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the next zeroOut bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.nextClearBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - previousSetBit
```
public <T> long previousSetBit(Access<T> access,
                               T handle,
                               long offset,
                               long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Returns the index of the nearest bit that is set to true that occurs on or before the specified starting index. If no such bit exists, or if -1 is given as the starting index, then -1 is returned.
    
    Specified by:
    
    previousSetBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the previous set bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.clearPreviousSetBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - clearPreviousSetBit
```
public <T> long clearPreviousSetBit(Access<T> access,
                                    T handle,
                                    long offset,
                                    long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Finds and clears the nearest bit that is set to true that occurs on or before the specified starting index. If no such bit exists, or if -1 is given as the starting index, then -1 is returned.
    
    Specified by:
    
    clearPreviousSetBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the previous set bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.previousSetBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - previousClearBit
```
public <T> long previousClearBit(Access<T> access,
                                 T handle,
                                 long offset,
                                 long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Returns the index of the nearest bit that is set to false that occurs on or before the specified starting index. If no such bit exists, or if -1 is given as the starting index, then -1 is returned.
    
    Specified by:
    
    previousClearBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the previous zeroOut bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.setPreviousClearBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - setPreviousClearBit
```
public <T> long setPreviousClearBit(Access<T> access,
                                    T handle,
                                    long offset,
                                    long fromIndex)
```
    Description copied from interface: BitSetFrame
    
    Finds and sets to true the nearest bit that is set to false that occurs on or before the specified starting index. If no such bit exists, or if -1 is given as the starting index, then -1 is returned.
    
    Specified by:
    
    setPreviousClearBit in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    Returns:
    
    the index of the previous zeroOut bit, or -1 if there is no such bit
    
    See Also:
    
    BitSetFrame.previousClearBit(net.openhft.chronicle.algo.bytes.Access<T>, T, long, long)
  - logicalSize
```
public long logicalSize()
```
    Description copied from interface: BitSetFrame
    
    Number of bits in this frame. The index of the last bit in the set eligible to be set or zeroOut is logicalSize() - 1.
    
    Specified by:
    
    logicalSize in interface BitSetFrame
    
    Returns:
    
    the number of bits in this bit set
  - sizeInBytes
```
public long sizeInBytes()
```
    Description copied from interface: BitSetFrame
    
    Number of bytes taken by this frame.
    
    Specified by:
    
    sizeInBytes in interface BitSetFrame
  - cardinality
```
public <T> long cardinality(Access<T> access,
                            T handle,
                            long offset)
```
    Description copied from interface: BitSetFrame
    
    Returns the number of bits set to true in the bit set.
    
    Specified by:
    
    cardinality in interface BitSetFrame
  - setNextNContinuousClearBits
```
public <T> long setNextNContinuousClearBits(Access<T> access,
                                            T handle,
                                            long offset,
                                            long fromIndex,
                                            int numberOfBits)
```
    WARNING! This implementation doesn't strictly follow the contract from DirectBitSet interface. For the sake of atomicity this implementation couldn't find and flip the range crossing native word boundary, e. g. bits from 55 to 75 (boundary is 64).
    
    Specified by:
    
    setNextNContinuousClearBits in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    numberOfBits - how many continuous clear bits to search and set
    
    Returns:
    
    the index of the first bit in the found range of clear bits, or -1 if there is no such range
    
    Throws:
    
    IllegalArgumentException - if numberOfBits is out of range 0 < numberOfBits && numberOfBits <= 64
  - clearNextNContinuousSetBits
```
public <T> long clearNextNContinuousSetBits(Access<T> access,
                                            T handle,
                                            long offset,
                                            long fromIndex,
                                            int numberOfBits)
```
    WARNING! This implementation doesn't strictly follow the contract from BitSetFrame interface. For the sake of atomicity this implementation couldn't find and flip the range crossing native word boundary, e. g. bits from 55 to 75 (boundary is 64).
    
    Specified by:
    
    clearNextNContinuousSetBits in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    numberOfBits - how many continuous set bits to search and clear
    
    Returns:
    
    the index of the first bit in the found range of true bits, or -1 if there is no such range
    
    Throws:
    
    IllegalArgumentException - if numberOfBits is out of range 0 < numberOfBits && numberOfBits <= 64
  - setPreviousNContinuousClearBits
```
public <T> long setPreviousNContinuousClearBits(Access<T> access,
                                                T handle,
                                                long offset,
                                                long fromIndex,
                                                int numberOfBits)
```
    WARNING! This implementation doesn't strictly follow the contract from DirectBitSet interface. For the sake of atomicity this implementation couldn't find and flip the range crossing native word boundary, e. g. bits from 55 to 75 (boundary is 64).
    
    Specified by:
    
    setPreviousNContinuousClearBits in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    numberOfBits - how many continuous clear bits to search and set
    
    Returns:
    
    the index of the first bit in the found range of clear bits, or -1 if there is no such range
    
    Throws:
    
    IllegalArgumentException - if numberOfBits is out of range 0 < numberOfBits && numberOfBits <= 64
  - clearPreviousNContinuousSetBits
```
public <T> long clearPreviousNContinuousSetBits(Access<T> access,
                                                T handle,
                                                long offset,
                                                long fromIndex,
                                                int numberOfBits)
```
    WARNING! This implementation doesn't strictly follow the contract from DirectBitSet interface. For the sake of atomicity this implementation couldn't find and flip the range crossing native word boundary, e. g. bits from 55 to 75 (boundary is 64).
    
    Specified by:
    
    clearPreviousNContinuousSetBits in interface BitSetFrame
    
    fromIndex - the index to start checking from (inclusive)
    
    numberOfBits - how many continuous set bits to search and clear
    
    Returns:
    
    the index of the first bit in the found range of true bits, or -1 if there is no such range
    
    Throws:
    
    IllegalArgumentException - if numberOfBits is out of range 0 < numberOfBits && numberOfBits <= 64

Class ConcurrentFlatBitSetFrame

Nested Class Summary

Nested classes/interfaces inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame

Field Summary

Fields inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.chronicle.algo.bitset.BitSetFrame

Constructor Detail

ConcurrentFlatBitSetFrame

Method Detail

flip

flipRange

set

setIfClear

setRange

setAll

clear

clearIfSet

clearRange

clearAll

get

isRangeSet

isRangeClear

nextSetBit

setBits

algorithm

clearNextSetBit

nextClearBit

setNextClearBit

previousSetBit

clearPreviousSetBit

previousClearBit

setPreviousClearBit

logicalSize

sizeInBytes

cardinality

setNextNContinuousClearBits

clearNextNContinuousSetBits

setPreviousNContinuousClearBits

clearPreviousNContinuousSetBits