Struct RawVector 

pub struct RawVector { /* private fields */ }

A contiguous growable array of bits and up to 64-bit integers based on Vec of u64 values.

There are no iterators over the vector, because it may contain items of varying widths.

Notes

• The unused part of the last integer is always set to 0.
• The underlying vector may allocate but not use more integers than are strictly necessary.
• RawVector never panics from I/O errors.

Implementations

impl RawVector

pub fn len(&self) -> usize

Returns the length of the vector in bits.

pub fn is_empty(&self) -> bool

Returns true if the vector is empty.

pub fn capacity(&self) -> usize

Returns the capacity of the vector in bits.

pub fn count_ones(&self) -> usize

Counts the number of ones in the bit array.

Examples

use simple_sds_sbwt::raw_vector::{RawVector, AccessRaw};

let mut v = RawVector::with_len(137, false);
assert_eq!(v.count_ones(), 0);
v.set_bit(1, true); v.set_bit(33, true); v.set_bit(95, true); v.set_bit(123, true);
assert_eq!(v.count_ones(), 4);

pub fn new() -> RawVector

Creates an empty vector.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let v = RawVector::new();
assert!(v.is_empty());
assert_eq!(v.capacity(), 0);

pub fn with_len(len: usize, value: bool) -> RawVector

Creates an initialized vector of specified length.

Arguments

• len: Length of the vector in bits.
• value: Initialization value.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let v = RawVector::with_len(137, false);
assert_eq!(v.len(), 137);

pub fn with_capacity(capacity: usize) -> RawVector

Creates an empty vector with enough capacity for at least capacity bits.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let v = RawVector::with_capacity(137);
assert!(v.capacity() >= 137);

pub fn size_by_params(capacity: usize) -> usize

Returns the size of a serialized vector with the given capacity in u64 elements.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

assert_eq!(RawVector::size_by_params(247), 6);

pub fn complement(&self) -> RawVector

Returns a copy of the vector with each bit flipped.

Examples

use simple_sds_sbwt::raw_vector::{RawVector, AccessRaw};

let mut original = RawVector::with_len(137, false);
original.set_bit(1, true); original.set_bit(33, true);
unsafe { original.set_int(95, 456, 9); } original.set_bit(123, true);
let complement = original.complement();
for i in 0..137 {
    assert_eq!(!(complement.bit(i)), original.bit(i));
}

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

Resizes the vector to a specified length.

If new_len > self.len(), the new new_len - self.len() bits will be initialized. If new_len < self.len(), the vector is truncated.

Arguments

• new_len: New length of the vector in bits.
• value: Initialization value.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let mut v = RawVector::new();
v.resize(137, true);
let w = RawVector::with_len(137, true);
assert_eq!(v, w);

pub fn clear(&mut self)

Clears the vector without freeing the data.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let mut v = RawVector::with_len(137, true);
assert_eq!(v.len(), 137);
v.clear();
assert!(v.is_empty());

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

Reserves space for storing at least self.len() + additional bits in the vector.

Does nothing if the capacity is already sufficient.

Examples

use simple_sds_sbwt::raw_vector::RawVector;

let mut v = RawVector::with_len(137, false);
v.reserve(318);
assert!(v.capacity() >= 137 + 318);

Panics

May panic if self.len() + additional + 63 > usize::MAX.

pub fn get_words(&self) -> &[u64]

Trait Implementations

impl AccessRaw for RawVector

fn bit(&self, bit_offset: usize) -> bool

Reads a bit from the array.

unsafe fn int(&self, bit_offset: usize, width: usize) -> u64

Reads an integer from the container.

fn word(&self, index: usize) -> u64

Reads a 64-bit word from the container.

unsafe fn word_unchecked(&self, index: usize) -> u64

Unsafe version of AccessRaw::word without bounds checks.

fn is_mutable(&self) -> bool

Returns true if the underlying data is mutable.

fn set_bit(&mut self, bit_offset: usize, value: bool)

Writes a bit to the container.

unsafe fn set_int(&mut self, bit_offset: usize, value: u64, width: usize)

Writes an integer to the container.

impl AsRef<[u64]> for RawVector

fn as_ref(&self) -> &[u64]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<RawVector> for BitVector

fn as_ref(&self) -> &RawVector

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<RawVector> for IntVector

fn as_ref(&self) -> &RawVector

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for RawVector

fn clone(&self) -> RawVector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawVector

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

Formats the value using the given formatter.

impl Default for RawVector

fn default() -> RawVector

Returns the “default value” for a type.

impl From<BitVector> for RawVector

fn from(source: BitVector) -> Self

Converts to this type from the input type.

impl From<IntVector> for RawVector

fn from(source: IntVector) -> Self

Converts to this type from the input type.

impl From<RawVector> for BitVector

fn from(data: RawVector) -> Self

Converts to this type from the input type.

impl PartialEq for RawVector

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PopRaw for RawVector

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

Removes and returns the last bit from the container.

unsafe fn pop_int(&mut self, width: usize) -> Option<u64>

Removes and returns the last width bits from the container as an integer.

impl PushRaw for RawVector

fn push_bit(&mut self, value: bool)

Appends a bit to the container.

unsafe fn push_int(&mut self, value: u64, width: usize)

Appends an integer to the container.

impl Serialize for RawVector

fn serialize_header<T: Write>(&self, writer: &mut T) -> Result<()>

Serializes the header to the writer.

fn serialize_body<T: Write>(&self, writer: &mut T) -> Result<()>

Serializes the body to the writer.

fn load<T: Read>(reader: &mut T) -> Result<Self>

Loads the struct from the reader.

fn size_in_elements(&self) -> usize

Returns the size of the serialized struct in u64 elements.

fn serialize<T: Write>(&self, writer: &mut T) -> Result<()>

Serializes the struct to the writer.

fn size_in_bytes(&self) -> usize

Returns the size of the serialized struct in bytes.

impl Eq for RawVector

impl StructuralPartialEq for RawVector