Struct succinct::IntVector

pub struct IntVector<Block: BlockType = usize> { /* fields omitted */ }

Uncompressed vector of k-bit unsigned integers.

The element width k is determined at vector creation time.

Block gives the representation type. The element width k can never exceed the number of bits in Block.

Methods

impl<Block: BlockType> IntVector<Block>

pub fn new(element_bits: usize) -> Self

Creates a new integer vector.

Arguments

• element_bits — the size of each element in bits; hence elements range from 0 to 2.pow(element_bits) - 1.

Result

The new, empty integer vector.

pub fn with_capacity(element_bits: usize, capacity: u64) -> Self

Creates a new, empty integer vector, allocating sufficient storage for capacity elements.

pub fn block_with_capacity(element_bits: usize, block_capacity: usize) -> Self

Creates a new, empty integer vector, allocating block_capacity blocks of storage.

pub fn with_fill(element_bits: usize, len: u64, value: Block) -> Self

Creates a new integer vector containing len copies of value.

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

Creates a new integer vector containing block_len copies of the block value.

The length of the new vector will be the number of elements of size element_bits that fit in block_len blocks.

pub fn get_random(
    &self,
    bit_offset: u64,
    element_bits: usize,
    element_index: u64
) -> Block

Returns the element at a given index, also given an arbitrary element size and bit offset.

This computes the location of the element_indexth element supposing that elements are element_bits side, then adds bit_offset additional bits and returns the element_bits-bit value found at that location.

Panics

Panics if the referenced bits are out of bounds. Bounds are considered to the end of the support array, even if that goes past the last element of the IntArray.

pub fn set_random(
    &mut self,
    bit_offset: u64,
    element_bits: usize,
    element_index: u64,
    element_value: Block
)

Sets the element at a given index to a given value, also given an arbitrary element size and bit offset.

This computes the location of the element_indexth element supposing that elements are element_bits side, then adds bit_offset additional bits and modifies the element_bits-bit value found at that location.

Panics

• Panics if the referenced bits are out of bounds. Bounds are considered to the end of the support array, even if that goes past the last element of the IntArray.

• Debug mode only: Panics if element_value is too large to fit in the element size. (TODO: What’s the right thing here?)

pub fn push(&mut self, element_value: Block)

Pushes an element onto the end of the vector, increasing the length by 1.

pub fn pop(&mut self) -> Option<Block>

Removes and returns the last element of the vector, if present.

pub fn capacity(&self) -> u64

The number of elements the vector can hold without reallocating.

pub fn block_capacity(&self) -> usize

The number of blocks of elements the vector can hold without reallocating.

pub fn resize(&mut self, n_elements: u64, fill: Block)

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

pub fn block_resize(&mut self, n_blocks: usize, fill: Block)

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

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

Reserves capacity for at least additional more elements to be inserted in the given IntVector<Block>.

The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the size conditions of IntVector::<Block>::is_okay_size() are not met. This will happen if the total number of bits overflows u64.

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

Reserves capacity for at least additional blocks of values 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 elements to be inserted in the given IntVector<Block>.

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

Panics

Panics if the size conditions of IntVector::<Block>::is_okay_size() are not met. This will happen if the total number of bits overflows u64.

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

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

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

The collection may reserve more space to avoid frequent reallocations.

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, n_elements: u64)

Shrinks to the given size.

Does nothing if n_elements is greater than the current size.

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

Shrinks to the given number of blocks.

Does nothing if n_blocks is greater than the current 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 = Block;

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

Gets an iterator over the elements of the vector.

pub fn is_block_sized(&self) -> bool

True if the element size matches the block size.

pub fn is_aligned(&self) -> bool

True if elements are aligned within blocks.

Trait Implementations

impl<A: BlockType> SpaceUsage for IntVector<A>

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 IntVector<Block>

type Block = Block

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

fn block_len(&self) -> usize

The length of the slice in blocks.

fn bit_len(&self) -> u64

The length of the slice in bits.

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

Gets the block at position

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

Gets the bit at position

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 IntVector<Block>

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

Sets the block at position to value.

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

Sets the bit 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> IntVec for IntVector<Block>

type Block = Block

The type of primitive value to represent elements.

fn len(&self) -> u64

The number of elements.

fn get(&self, element_index: u64) -> Block

Fetches the value of the indexth element.

fn element_bits(&self) -> usize

The bit width of each element.

fn is_empty(&self) -> bool

Is the vector empty?

impl<Block: BlockType> IntVecMut for IntVector<Block>

fn set(&mut self, element_index: u64, element_value: Block)

Updates the value of the indexth element.

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

fn cmp(&self, other: &IntVector<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<IntVector<Block>> for IntVector<Block>

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

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

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

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

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

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

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

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

fn ge(&self, other: &IntVector<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<IntVector<Block>> for IntVector<Block>

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

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

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

This method tests for !=.

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

type Item = Block

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 IntVector<Block>

fn clone(&self) -> IntVector<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 IntVector<Block>

impl<Block> Debug for IntVector<Block> where
    Block: BlockType + Debug, 

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

Formats the value using the given formatter.

impl<Block: Hash + BlockType> Hash for IntVector<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].