Struct RawVectorMapper 

pub struct RawVectorMapper<'a> { /* private fields */ }

An immutable memory-mapped RawVector.

This is compatible with the serialization format of RawVector.

Examples

use simple_sds_sbwt::raw_vector::{RawVector, RawVectorMapper, AccessRaw, PushRaw};
use simple_sds_sbwt::serialize::{MemoryMap, MemoryMapped, MappingMode};
use simple_sds_sbwt::serialize;
use std::fs;

let filename = serialize::temp_file_name("raw-vector-mapper");
let width = 29;
let mut original = RawVector::new();
unsafe {
    original.push_int(123, width);
    original.push_int(456, width);
    original.push_int(789, width);
}
serialize::serialize_to(&original, &filename);

let map = MemoryMap::new(&filename, MappingMode::ReadOnly).unwrap();
let mapper = RawVectorMapper::new(&map, 0).unwrap();
assert_eq!(mapper.len(), 3 * width);
unsafe {
    assert_eq!(mapper.int(0, width), 123);
    assert_eq!(mapper.int(width, width), 456);
    assert_eq!(mapper.int(2 * width, width), 789);
}

drop(mapper); drop(map);
fs::remove_file(&filename);

Implementations

impl<'a> RawVectorMapper<'a>

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 count_ones(&self) -> usize

Counts the number of ones in the bit array.

Trait Implementations

impl<'a> AccessRaw for RawVectorMapper<'a>

Available on non-target_family=wasm only.

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, _: usize, _: bool)

Writes a bit to the container.

unsafe fn set_int(&mut self, _: usize, _: u64, _: usize)

Writes an integer to the container.

impl<'a> AsRef<MappedSlice<'a, u64>> for RawVectorMapper<'a>

Available on non-target_family=wasm only.

fn as_ref(&self) -> &MappedSlice<'a, u64>

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

impl<'a> AsRef<RawVectorMapper<'a>> for IntVectorMapper<'a>

Available on non-target_family=wasm only.

fn as_ref(&self) -> &RawVectorMapper<'a>

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

impl<'a> Debug for RawVectorMapper<'a>

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

Formats the value using the given formatter.

impl<'a> MemoryMapped<'a> for RawVectorMapper<'a>

Available on non-target_family=wasm only.

fn new(map: &'a MemoryMap, offset: usize) -> Result<Self>

Returns an immutable memory-mapped structure corresponding to an interval in the file.

fn map_offset(&self) -> usize

Returns the starting offset in the file.

fn map_len(&self) -> usize

Returns the length of the interval corresponding to the structure.

impl<'a> PartialEq for RawVectorMapper<'a>

fn eq(&self, other: &RawVectorMapper<'a>) -> 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<'a> Eq for RawVectorMapper<'a>

impl<'a> StructuralPartialEq for RawVectorMapper<'a>