Struct rxing::common::BitArray

pub struct BitArray { /* private fields */ }

A simple, fast array of bits, represented compactly by an array of ints internally.

@author Sean Owen

Implementations

impl BitArray

pub fn new() -> Self

pub fn with_size(size: usize) -> Self

pub fn getSize(&self) -> usize

pub fn getSizeInBytes(&self) -> usize

pub fn get(&self, i: usize) -> bool

@param i bit to get @return true iff bit i is set

pub fn set(&mut self, i: usize)

Sets bit i.

@param i bit to set

pub fn flip(&mut self, i: usize)

Flips bit i.

@param i bit to set

pub fn getNextSet(&self, from: usize) -> usize

@param from first bit to check @return index of first bit that is set, starting from the given index, or size if none are set at or beyond this given index @see #getNextUnset(int)

pub fn getNextUnset(&self, from: usize) -> usize

@param from index to start looking for unset bit @return index of next unset bit, or {@code size} if none are unset until the end @see #getNextSet(int)

pub fn setBulk(&mut self, i: usize, newBits: u32)

Sets a block of 32 bits, starting at bit i.

@param i first bit to set @param newBits the new value of the next 32 bits. Note again that the least-significant bit corresponds to bit i, the next-least-significant to i+1, and so on.

pub fn setRange(&mut self, start: usize, end: usize) -> Result<(), Exceptions>

Sets a range of bits.

@param start start of range, inclusive. @param end end of range, exclusive

pub fn clear(&mut self)

Clears all bits (sets to false).

pub fn isRange(
    &self,
    start: usize,
    end: usize,
    value: bool
) -> Result<bool, Exceptions>

Efficient method to check if a range of bits is set, or not set.

@param start start of range, inclusive. @param end end of range, exclusive @param value if true, checks that bits in range are set, otherwise checks that they are not set @return true iff all bits are set or not set in range, according to value argument @throws IllegalArgumentException if end is less than start or the range is not contained in the array

pub fn appendBit(&mut self, bit: bool)

pub fn appendBits(
    &mut self,
    value: u32,
    num_bits: usize
) -> Result<(), Exceptions>

Appends the least-significant bits, from value, in order from most-significant to least-significant. For example, appending 6 bits from 0x000001E will append the bits 0, 1, 1, 1, 1, 0 in that order.

@param value {@code int} containing bits to append @param numBits bits from value to append

pub fn appendBitArray(&mut self, other: BitArray)

pub fn xor(&mut self, other: &BitArray) -> Result<(), Exceptions>

pub fn toBytes(
    &self,
    bitOffset: usize,
    array: &mut [u8],
    offset: usize,
    numBytes: usize
)

@param bitOffset first bit to start writing @param array array to write into. Bytes are written most-significant byte first. This is the opposite of the internal representation, which is exposed by {@link #getBitArray()} @param offset position in array to start writing @param numBytes how many bytes to write

pub fn getBitArray(&self) -> &[u32]

@return underlying array of ints. The first element holds the first 32 bits, and the least significant bit is bit 0.

pub fn reverse(&mut self)

Reverses all bits in the array.

Trait Implementations

impl Clone for BitArray

fn clone(&self) -> BitArray

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BitArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BitArray

fn default() -> Self

Returns the “default value” for a type.

impl Display for BitArray

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for BitArray

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<BitArray> for BitArray

fn eq(&self, other: &BitArray) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for BitArray

impl StructuralEq for BitArray

impl StructuralPartialEq for BitArray