Struct packedvec::PackedVec [−][src]
pub struct PackedVec<T, StorageT = usize> { /* fields omitted */ }
Expand description
A PackedVec
stores vectors of integers efficiently while providing
an API similar to Vec
. The basic idea is to store each element using the minimum number of
bits needed to represent every element in the Vec
. For example, if we have a Vec<u64>
with
elements [20, 30, 140], every element wastes most of its 64 bits: 7 bits is sufficient to
represent the range of elements in the vector. Given this input vector, PackedVec
stores each
elements using exactly 7 bits, saving substantial memory. For vectors which often contain small
ranges of numbers, and which are created rarely, but read from frequently, this can be a
significant memory and performance win.
Examples
PackedVec
has two main API differences from Vec
: a PackedVec
is created from a Vec
; and
a PackedVec
returns values rather than references. Both points can be seen in this example:
use packedvec::PackedVec; let v = vec![-1, 30, 120]; let pv = PackedVec::new(v.clone()); assert_eq!(pv.get(0), Some(-1)); assert_eq!(pv.get(2), Some(120)); assert_eq!(pv.get(3), None); assert_eq!(v.iter().cloned().collect::<Vec<_>>(), pv.iter().collect::<Vec<_>>());
Storage backing type
PackedVec
defaults to using usize
as a storage backing type. You can choose your own
storage type with the new_with_storaget()
constructor. In general we recommend using the default usize
backing storage unless you have
rigorously benchmarked your particular use case and are sure that a different storage type is
superior.
Implementations
impl<'a, T> PackedVec<T, usize> where
T: 'static + AsPrimitive<usize> + FromPrimitive + Ord + PrimInt + ToPrimitive,
usize: AsPrimitive<T>,
impl<'a, T> PackedVec<T, usize> where
T: 'static + AsPrimitive<usize> + FromPrimitive + Ord + PrimInt + ToPrimitive,
usize: AsPrimitive<T>,
impl<'a, T, StorageT> PackedVec<T, StorageT> where
T: 'static + AsPrimitive<StorageT> + FromPrimitive + Ord + PrimInt + ToPrimitive,
StorageT: AsPrimitive<T> + PrimInt + Unsigned,
impl<'a, T, StorageT> PackedVec<T, StorageT> where
T: 'static + AsPrimitive<StorageT> + FromPrimitive + Ord + PrimInt + ToPrimitive,
StorageT: AsPrimitive<T> + PrimInt + Unsigned,
Constructs a new PackedVec
from vec
(with a user-defined backing storage type).
Return the value at the specified index
.
Example
use packedvec::PackedVec; let v: Vec<u8> = vec![1, 2, 3, 4]; let packedvec = PackedVec::new(v); let val: Option<u8> = packedvec.get(3); assert_eq!(val, Some(4));
Returns a reference to an element or subslice, without doing bounds checking.
This is generally not recommended, use with caution! For a safe alternative see
get()
.
Safety
The caller must ensure that the index specified does not exceed this
PackedVec
’s bound.
Example
use packedvec::PackedVec; let v: Vec<u8> = vec![1, 2, 3, 4]; let packedvec = PackedVec::new(v); assert_eq!(unsafe { packedvec.get_unchecked(3) }, 4);
Returns true if the PackedVec
has no elements.
Example
use packedvec::PackedVec; let v: Vec<u16> = vec![]; let packedvec = PackedVec::new(v); assert_eq!(packedvec.is_empty(), true); let v: Vec<u16> = vec![1, 2, 3, 4]; let packedvec = PackedVec::new(v); assert_eq!(packedvec.is_empty(), false);
Return the number of elements in this PackedVec
.
Example
use packedvec::PackedVec; let v: Vec<u16> = vec![1, 2, 3, 4]; let packedvec = PackedVec::new(v); assert_eq!(packedvec.len(), 4);
How many bits does each packed element consume?
Example
use packedvec::PackedVec; let packedvec = PackedVec::new(vec![1, 2, 3, 4]); assert_eq!(packedvec.bwidth(), 2);
pub fn iter(&'a self) -> PackedVecIter<'a, T, StorageT>ⓘNotable traits for PackedVecIter<'a, T, StorageT>impl<'a, T, StorageT> Iterator for PackedVecIter<'a, T, StorageT> where
T: 'static + AsPrimitive<StorageT> + FromPrimitive + Ord + PrimInt + ToPrimitive,
StorageT: AsPrimitive<T> + PrimInt + Unsigned, type Item = T;
pub fn iter(&'a self) -> PackedVecIter<'a, T, StorageT>ⓘNotable traits for PackedVecIter<'a, T, StorageT>impl<'a, T, StorageT> Iterator for PackedVecIter<'a, T, StorageT> where
T: 'static + AsPrimitive<StorageT> + FromPrimitive + Ord + PrimInt + ToPrimitive,
StorageT: AsPrimitive<T> + PrimInt + Unsigned, type Item = T;
impl<'a, T, StorageT> Iterator for PackedVecIter<'a, T, StorageT> where
T: 'static + AsPrimitive<StorageT> + FromPrimitive + Ord + PrimInt + ToPrimitive,
StorageT: AsPrimitive<T> + PrimInt + Unsigned, type Item = T;
Returns an iterator over the PackedVec
.
Trait Implementations
Auto Trait Implementations
impl<T, StorageT> RefUnwindSafe for PackedVec<T, StorageT> where
StorageT: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, StorageT> UnwindSafe for PackedVec<T, StorageT> where
StorageT: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more