Enum BucketIndex 

#[repr(usize)]
enum BucketIndex {
    Bucket00 = 0,
    Bucket01 = 1,
    Bucket02 = 2,
    Bucket03 = 3,
    Bucket04 = 4,
    Bucket05 = 5,
    Bucket06 = 6,
    Bucket07 = 7,
    Bucket08 = 8,
    Bucket09 = 9,
    Bucket10 = 10,
    Bucket11 = 11,
    Bucket12 = 12,
    Bucket13 = 13,
    Bucket14 = 14,
    Bucket15 = 15,
    Bucket16 = 16,
    Bucket17 = 17,
    Bucket18 = 18,
    Bucket19 = 19,
    Bucket20 = 20,
}

Index into an array of buckets.

Using an enum lets us tell the compiler that values range from 0 to 20, allowing array bounds checks to be optimized away, without having to resort to pattern types or other unstable features.

Variants

Bucket00 = 0

Bucket01 = 1

Bucket02 = 2

Bucket03 = 3

Bucket04 = 4

Bucket05 = 5

Bucket06 = 6

Bucket07 = 7

Bucket08 = 8

Bucket09 = 9

Bucket10 = 10

Bucket11 = 11

Bucket12 = 12

Bucket13 = 13

Bucket14 = 14

Bucket15 = 15

Bucket16 = 16

Bucket17 = 17

Bucket18 = 18

Bucket19 = 19

Bucket20 = 20

Implementations

impl BucketIndex

const BUCKET_0_CAPACITY: usize

Capacity of bucket 0 (and also of bucket 1).

const NONZERO_BUCKET_SHIFT_ADJUST: usize = 11

Adjustment factor from the highest-set-bit-position of a flat index, to its corresponding bucket number.

For example, the first flat-index in bucket 2 is 8192. Its highest-set-bit-position is (8192).ilog2() == 13, and subtracting the adjustment factor of 11 gives the bucket number of 2.

const fn to_usize(self) -> usize

const fn from_raw(raw: usize) -> Self

const fn capacity(self) -> usize

Total number of slots in this bucket.

const fn from_flat_index(flat: usize) -> (Self, usize)

Converts a flat index in the range 0..=u32::MAX into a bucket index, and a slot offset within that bucket.

Panics if flat > u32::MAX.

fn iter_all() -> impl ExactSizeIterator<Item = Self>

fn enumerate_buckets<T>( buckets: &[T; 21], ) -> impl ExactSizeIterator<Item = (Self, &T)>

Trait Implementations

impl Clone for BucketIndex

fn clone(&self) -> BucketIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BucketIndex

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

Formats the value using the given formatter.

impl<T> Index<BucketIndex> for [T; 21]

type Output = T

The returned type after indexing.

fn index(&self, index: BucketIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<BucketIndex> for [T; 21]

fn index_mut(&mut self, index: BucketIndex) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for BucketIndex

fn eq(&self, other: &BucketIndex) -> 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 Copy for BucketIndex

impl Eq for BucketIndex

impl StructuralPartialEq for BucketIndex

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes

Size for each variant:

• Bucket00: 0 bytes
• Bucket01: 0 bytes
• Bucket02: 0 bytes
• Bucket03: 0 bytes
• Bucket04: 0 bytes
• Bucket05: 0 bytes
• Bucket06: 0 bytes
• Bucket07: 0 bytes
• Bucket08: 0 bytes
• Bucket09: 0 bytes
• Bucket10: 0 bytes
• Bucket11: 0 bytes
• Bucket12: 0 bytes
• Bucket13: 0 bytes
• Bucket14: 0 bytes
• Bucket15: 0 bytes
• Bucket16: 0 bytes
• Bucket17: 0 bytes
• Bucket18: 0 bytes
• Bucket19: 0 bytes
• Bucket20: 0 bytes