Struct succinct::BitVector

pub struct BitVector<Block: BlockType = usize>(_);

Uncompressed vector of bits.

Methods

impl<Block: BlockType> BitVector<Block>

pub fn new() -> Self

Creates a new, empty bit vector.

pub fn with_capacity(capacity: u64) -> Self

Creates a new, empty bit vector with space allocated for capacity bits.

Panics

Panics if capacity is too large. In particular the number of blocks required by the capacity (capacity / Block::nbits()) must fit in a usize.

pub fn block_with_capacity(capacity: usize) -> Self

Creates a new, empty bit vector with space allocated for capacity blocks.

pub fn with_fill(len: u64, value: bool) -> Self

Creates a new bit vector of len bits initialized to value.

Panics

Panics if len is too large. In particular the number of blocks required by the capacity (len / Block::nbits()) must fit in a usize.

pub fn block_with_fill(block_len: usize, value: Block) -> Self

Creates a new bit vector of block_len blocks initialized to value.

pub fn capacity(&self) -> u64

How many bits the bit vector can hold without reallocating.

pub fn block_capacity(&self) -> usize

How many blocks the bit vector can hold without reallocating.

pub fn resize(&mut self, new_len: u64, value: bool)

Resizes the bit vector to the given number of elements, filling if necessary.

Panics

Panics if new_len is too large. In particular the number of blocks required by the capacity (new_len / Block::nbits()) must fit in a usize.

pub fn block_resize(&mut self, new_len: usize, value: Block)

Resizes the bit vector to the given number of blocks, filling if necessary.

pub fn reserve(&mut self, additional: u64)

Reserves capacity for at least additional more bits to be inserted.

The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the number of blocks overflows a usize.

pub fn block_reserve(&mut self, additional: usize)

Reserves capacity for at least additional blocks of bits to be inserted.

The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the number of blocks overflows a usize.

pub fn reserve_exact(&mut self, additional: u64)

Reserves capacity for at least additional more bits to be inserted.

Unlike reserve, does nothing if the capacity is already sufficient.

Panics

Panics if the number of blocks overflows a usize.

pub fn block_reserve_exact(&mut self, additional: usize)

Reserves capacity for at least additional more blocks of bits to be inserted.

Unlike reserve_block, does nothing if the capacity is already sufficient.

Panics

Panics if the number of blocks overflows a usize.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity to just fit the number of elements.

pub fn truncate(&mut self, len: u64)

Shrinks to the given size.

Does nothing if len is greater than the current size.

pub fn block_truncate(&mut self, block_len: usize)

Shrinks to the given size in blocks.

Does nothing if block_len is greater than the current size in blocks.

pub fn clear(&mut self)

Sets the size to 0 while retaining the allocated storage.

Important traits for Iter<'a, Block>

impl<'a, Block: BlockType> Iterator for Iter<'a, Block> type Item = bool;

pub fn iter(&self) -> Iter<Block>

Returns an iterator over the bits of the bit vector

Trait Implementations

impl<Block: BlockType> SpaceUsage for BitVector<Block>

fn is_stack_only() -> bool

Is the size of this type known statically?

fn heap_bytes(&self) -> usize

Calculates the heap portion of the size of an object.

fn total_bytes(&self) -> usize

Computes the size of the receiver in bytes.

fn stack_bytes() -> usize

Calculates the stack portion of the size of this type.

impl<Block: BlockType> BitVec for BitVector<Block>

type Block = Block

The underlying block type used to store the bits of the vector.

fn bit_len(&self) -> u64

The length of the slice in bits.

fn get_bit(&self, index: u64) -> bool

Gets the bit at position

fn get_block(&self, index: usize) -> Block

Gets the block at position

fn block_len(&self) -> usize

The length of the slice in blocks.

fn get_bits(&self, start: u64, count: usize) -> Self::Block

Gets count bits starting at bit index start, interpreted as a little-endian integer.

impl<Block: BlockType> BitVecMut for BitVector<Block>

fn set_bit(&mut self, index: u64, value: bool)

Sets the bit at position to value.

fn set_block(&mut self, index: usize, value: Block)

Sets the block at position to value.

fn set_bits(&mut self, start: u64, count: usize, value: Self::Block)

Sets count bits starting at bit index start, interpreted as a little-endian integer.

impl<Block: BlockType> BitVecPush for BitVector<Block>

fn push_bit(&mut self, value: bool)

Adds the given bit to the end of the bit vector.

fn pop_bit(&mut self) -> Option<bool>

Removes and returns the last bit, if any.

fn push_block(&mut self, value: Block)

Pushes the given block onto the end of the bit vector.

fn align_block(&mut self, value: bool)

Pushes value 0 or more times until the size of the bit vector is block-aligned.

impl<Block: Ord + BlockType> Ord for BitVector<Block>

fn cmp(&self, other: &BitVector<Block>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Block: PartialOrd + BlockType> PartialOrd<BitVector<Block>> for BitVector<Block>

fn partial_cmp(&self, other: &BitVector<Block>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &BitVector<Block>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &BitVector<Block>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &BitVector<Block>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &BitVector<Block>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Block: PartialEq + BlockType> PartialEq<BitVector<Block>> for BitVector<Block>

fn eq(&self, other: &BitVector<Block>) -> bool

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

fn ne(&self, other: &BitVector<Block>) -> bool

This method tests for !=.

impl<Block: BlockType> Default for BitVector<Block>

fn default() -> Self

Returns the "default value" for a type.

impl<'a, Block: BlockType + 'a> IntoIterator for &'a BitVector<Block>

type Item = bool

The type of the elements being iterated over.

type IntoIter = Iter<'a, Block>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Block: Clone + BlockType> Clone for BitVector<Block>

fn clone(&self) -> BitVector<Block>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Block: Eq + BlockType> Eq for BitVector<Block>

impl<Block: Debug + BlockType> Debug for BitVector<Block>

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

Formats the value using the given formatter.

impl<Block: Hash + BlockType> Hash for BitVector<Block>

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, 

Feeds a slice of this type into the given [Hasher].

impl<Block: BlockType> Binary for BitVector<Block>

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.