Struct BitSet 

pub struct BitSet { /* private fields */ }

A variable-length bit array encoded as a VarInt-prefixed array of i64 values.

BitSet is used in the Minecraft protocol for chunk light masks, section bitmasks, and other bitfield data where an arbitrary number of boolean flags need to be packed efficiently. Each i64 holds 64 bits, and the array grows as needed to accommodate the highest set bit.

Wire format: VarInt(number of longs) followed by that many big-endian i64 values. An empty BitSet has zero longs.

Implementations

impl BitSet

pub fn new() -> Self

Creates a new empty BitSet with no bits set.

pub fn from_longs(data: Vec<i64>) -> Self

Creates a BitSet from a pre-existing vector of i64 words.

Each i64 holds 64 bits. The first element contains bits 0-63, the second 64-127, and so on. This is useful when constructing a BitSet from data received outside the protocol decoding path.

pub fn len(&self) -> usize

Returns the number of bits this BitSet can currently hold without growing (i.e., the number of longs × 64).

pub fn is_empty(&self) -> bool

Returns true if the BitSet contains no longs (zero capacity).

pub fn get(&self, index: usize) -> bool

Returns the value of the bit at the given index.

Returns false for indices beyond the current capacity — bits outside the allocated range are implicitly zero.

pub fn set(&mut self, index: usize, value: bool)

Sets or clears the bit at the given index.

If the index is beyond the current capacity and value is true, the internal storage is automatically extended with zero-filled longs. Setting a bit to false beyond the current capacity is a no-op (the bit is already implicitly zero).

Trait Implementations

impl Clone for BitSet

fn clone(&self) -> BitSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitSet

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

Formats the value using the given formatter.

impl Decode for BitSet

Decodes a BitSet from a VarInt-prefixed array of big-endian i64 values.

Reads the VarInt count, then that many 8-byte big-endian i64 values. Fails if the buffer doesn’t contain enough bytes for the declared number of longs.

fn decode(buf: &mut &[u8]) -> Result<Self>

Reads the VarInt length, then decodes that many i64 words.

Fails with Error::BufferUnderflow if the buffer is too short, or with Error::InvalidData if the declared length is negative.

impl Default for BitSet

fn default() -> Self

Returns the “default value” for a type.

impl Encode for BitSet

Encodes the BitSet as a VarInt-prefixed array of big-endian i64 values.

The VarInt indicates the number of longs in the array, followed by each long encoded as 8 big-endian bytes. An empty BitSet encodes as a single VarInt(0) byte.

fn encode(&self, buf: &mut Vec<u8>) -> Result<()>

Writes VarInt(number of longs) followed by each long as 8 big-endian bytes.

impl EncodedSize for BitSet

Computes the wire size of the BitSet.

The total size is the VarInt-encoded length prefix plus 8 bytes per long. This enables exact buffer pre-allocation before encoding.

fn encoded_size(&self) -> usize

Returns VarInt prefix size + (number of longs × 8).

impl Hash for BitSet

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BitSet

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

impl StructuralPartialEq for BitSet