Struct CompIntList 

pub struct CompIntList<B: Backend = BitVec<Box<[usize]>>, D = EfSeq<u64>> { /* private fields */ }

A compact list of integers not less than a given lower bound.

Each value x is stored as x − min + 1 (a strictly positive integer) by concatenating binary representations with the most significant bit removed. The boundaries between values are recorded in a SliceByValue<Value = u64> (by default an Elias–Fano sequence), enabling efficient random access.

After construction, the delimiter structure can be replaced using map_delimiters, and the data structure using map_data.

This structure implements the TryIntoUnaligned trait, allowing it to be converted into (usually faster) structures using unaligned access.

Type Parameters

• B: The data backend. Must implement Backend and BitVecValueOps<B::Word>. Defaults to [BitVec<Box<[usize]>>].
• D: The delimiter structure. Must implement SliceByValue<Value = u64>. Defaults to EfSeq<u64>.

Implementations

impl<V: Word> CompIntList<BitVec<Box<[V]>>>

pub fn new<I: ?Sized>(min: V, values: &I) -> Self

where for<'a> &'a I: IntoIterator<Item = &'a V>,

Creates a new CompIntList from a lower bound and a reference to a collection of values not less than min.

The collection is iterated twice: once to compute statistics (element count and total bit length), and once to build the delimiter and data structures.

Panics

Panics if any value is less than min.

Examples

let values = vec![1u64, 5, 10];
let list = CompIntList::new(1, &values);
assert_eq!(list.len(), 3);
assert_eq!(list.index_value(1), 5);

impl<B: Backend<Word: Word> + BitVecValueOps<B::Word>, D: SliceByValue<Value = u64>> CompIntList<B, D>

pub unsafe fn map_delimiters<F, D2>(self, func: F) -> CompIntList<B, D2>

where F: FnOnce(D) -> D2, D2: SliceByValue<Value = u64>,

Replaces the delimiter structure.

Safety

This method is unsafe because it is not possible to guarantee that the new delimiters return the same values as the old ones.

pub unsafe fn map_data<F, B2>(self, func: F) -> CompIntList<B2, D>

where F: FnOnce(B) -> B2, B2: Backend<Word = B::Word> + BitVecValueOps<B2::Word>,

Replaces the data structure.

Safety

This method is unsafe because it is not possible to guarantee that the new data returns the same values as the old one.

pub fn into_inner(self) -> D

Returns the underlying delimiter structure.

Trait Implementations

impl<B, D> AlignHash for CompIntList<B, D>

where usize: SerInner<SerType: AlignHash>, B::Word: SerInner<SerType: AlignHash>, D: SerInner<SerType: AlignHash>, B: SerInner<SerType: AlignHash> + Backend, bool: SerInner<SerType: AlignHash>,

fn align_hash(hasher: &mut impl Hasher, offset_of: &mut usize)

Accumulates alignment information in hasher assuming to be positioned at offset_of.

fn align_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Calls AlignHash::align_hash on a value.

impl<B: Clone + Backend, D: Clone> Clone for CompIntList<B, D>

where B::Word: Clone,

fn clone(&self) -> CompIntList<B, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Backend, D> CopyType for CompIntList<B, D>

type Copy = Deep

impl<B: Debug + Backend, D: Debug> Debug for CompIntList<B, D>

where B::Word: Debug,

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

Formats the value using the given formatter.

impl<B, D> DeserInner for CompIntList<B, D>

where usize: DeserInner, B::Word: DeserInner, D: DeserInner, B: DeserInner + Backend, bool: DeserInner, for<'a> <B as DeserInner>::DeserType<'a>: Backend<Word = B::Word>, for<'__epserde_desertype> DeserType<'__epserde_desertype, B>: Backend,

type DeserType<'__epserde_desertype> = CompIntList<<B as DeserInner>::DeserType<'__epserde_desertype>, <D as DeserInner>::DeserType<'__epserde_desertype>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

fn __check_covariance<'__long: '__short, '__short>( proof: CovariantProof<Self::DeserType<'__long>>, ) -> CovariantProof<Self::DeserType<'__short>>

Internal method for checking the covariance of DeserType.

unsafe fn _deser_full_inner( backend: &mut impl ReadWithPos, ) -> Result<Self, Error>

Safety

unsafe fn _deser_eps_inner<'deser_eps_inner_lifetime>( backend: &mut SliceWithPos<'deser_eps_inner_lifetime>, ) -> Result<Self::DeserType<'deser_eps_inner_lifetime>, Error>

Safety

impl<'de, B, D> Deserialize<'de> for CompIntList<B, D>

where B: Deserialize<'de> + Backend, D: Deserialize<'de>, B::Word: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<B, D> FlatType for CompIntList<B, D>

where usize: MemSize + FlatType, B::Word: MemSize + FlatType, D: MemSize + FlatType, B: MemSize + FlatType + Backend, bool: MemSize + FlatType,

type Flat = False

impl<V: Word, D, D2: SliceByValue<Value = u64>> From<CompIntList<BitVecU<Box<[V]>>, D>> for CompIntList<BitVec<Box<[V]>>, D2>

where D: Into<D2>,

fn from(c: CompIntList<BitVecU<Box<[V]>>, D>) -> Self

Converts to this type from the input type.

impl<B, D> MemDbgImpl for CompIntList<B, D>

where usize: MemDbgImpl + FlatType, B::Word: MemDbgImpl + FlatType, D: MemDbgImpl + FlatType, B: MemDbgImpl + FlatType + Backend, bool: MemDbgImpl + FlatType,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags, _memdbg_refs: &mut HashSet<usize>, ) -> Result

fn _mem_dbg_depth_on( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, dbg_refs: &mut HashSet<usize>, ) -> Result<(), Error>

fn _mem_dbg_depth_on_impl( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, dbg_refs: &mut HashSet<usize>, ref_display: RefDisplay, ) -> Result<(), Error>

Internal implementation for depth display.

impl<B, D> MemSize for CompIntList<B, D>

where usize: MemSize + FlatType, B::Word: MemSize + FlatType, D: MemSize + FlatType, B: MemSize + FlatType + Backend, bool: MemSize + FlatType,

fn mem_size_rec( &self, _memsize_flags: SizeFlags, _memsize_refs: &mut HashMap<usize, usize>, ) -> usize

Recursive implementation that tracks visited references for deduplication.

fn mem_size(&self, flags: SizeFlags) -> usize

Returns the (recursively computed) overall memory size of the structure in bytes.

impl<B, D> SerInner for CompIntList<B, D>

where usize: SerInner, B::Word: SerInner, D: SerInner, B: SerInner + Backend, bool: SerInner, SerType<B>: Backend,

const IS_ZERO_COPY: bool

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

type SerType = CompIntList<<B as SerInner>::SerType, <D as SerInner>::SerType>

This is the type that will be written in the header of the file, and thus the type that will be deserialized. In most cases it is Self, but in some cases, as for references to slices, it is customized.

unsafe fn _ser_inner(&self, backend: &mut impl WriteWithNames) -> Result<()>

Serializes this structure using the given backend.

impl<B, D> Serialize for CompIntList<B, D>

where B: Serialize + Backend, D: Serialize, B::Word: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<B: Backend<Word: Word> + BitVecValueOps<B::Word>, D: SliceByValue<Value = u64>> SliceByValue for CompIntList<B, D>

where for<'a> &'a D: IntoIteratorFrom, for<'a> <&'a D as IntoIteratorFrom>::IntoIterFrom: UncheckedIterator<Item = u64>,

type Value = <B as Backend>::Word

The type of the values in the slice.

fn len(&self) -> usize

See slice::len.

unsafe fn get_value_unchecked(&self, index: usize) -> B::Word

See slice::get_unchecked.

fn is_empty(&self) -> bool

See slice::is_empty.

fn index_value(&self, index: usize) -> Self::Value

See the Index implementation for slices.

fn get_value(&self, index: usize) -> Option<Self::Value>

See slice::get.

impl<V: Word, D: TryIntoUnaligned + SliceByValue<Value = u64>> TryIntoUnaligned for CompIntList<BitVec<Box<[V]>>, D>

where D::Unaligned: SliceByValue<Value = u64>,

fn try_into_unaligned(self) -> Result<Self::Unaligned, UnalignedConversionError>

This method will fail if any stored value has a bit width that does not satisfy the constraints for unaligned reads.

type Unaligned = CompIntList<BitVecU<Box<[V]>>, <D as TryIntoUnaligned>::Unaligned>

The unaligned version of this type.

impl<B, D> TypeHash for CompIntList<B, D>

where usize: SerInner<SerType: TypeHash>, B::Word: SerInner<SerType: TypeHash>, D: SerInner<SerType: TypeHash>, B: SerInner<SerType: TypeHash> + Backend, bool: SerInner<SerType: TypeHash>,

fn type_hash(hasher: &mut impl Hasher)

Accumulates type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Calls TypeHash::type_hash on a value.