Struct scale_bits::bits::Bits

pub struct Bits { /* private fields */ }

This represents a sequence of boolean values, packed into bits.

One of the defining features of this type is that it SCALE encodes and decodes into an identical representation to a BitVec<u8, Lsb0>, and has matching a scale_info::TypeInfo implementation to align with this. This allows it to be used in place of BitVec<u8, Lsb0> when you need something with an identical SCALE representation and a simple API and don’t wish to pull in the bitvec crate.

In addition to this, we can use the crate::scale::Format type to encode and decode Bits in the same way as BitVec’s do with order types of Lsb0 and Msb0, and store types of u8, u16, and u32.

With the serde feature enabled we can also serialize and seserialize Bits from sequences of booleans.

Example

use scale_bits::bits::Bits;

let mut bits = Bits::new();
bits.push(true);
bits.push(false);
bits.push(false);

assert_eq!(bits.len(), 3);

Converting to and from Vec<bool>:

use scale_bits::bits::Bits;

let bools = vec![true, false, true, false, true];
let bits: Bits = bools.into_iter().collect();

let new_bools: Vec<bool> = bits.into_iter().collect();
assert_eq!(new_bools, vec![true, false, true, false, true]);

Implementations

impl Bits

pub fn new() -> Self

Create a new empty list of bits. This does not allocate.

pub fn with_capacity(num_bits: usize) -> Self

Create a new empty list of bits. Pre-allocates enough space for the number of bits provided here.

pub fn is_empty(&self) -> bool

Returns true if no bits are stored.

Example

use scale_bits::bits::Bits;

let mut bits = Bits::new();
assert!(bits.is_empty());

bits.push(true);
assert!(!bits.is_empty());

bits.pop();
assert!(bits.is_empty());

pub fn len(&self) -> usize

Return the number of bits stored.

Example

use scale_bits::bits::Bits;

let mut bits = Bits::new();
assert_eq!(bits.len(), 0);

bits.push(true);
bits.push(false);
bits.push(true);
assert_eq!(bits.len(), 3);

bits.pop();
bits.pop();
assert_eq!(bits.len(), 1);

pub fn push(&mut self, b: bool)

Push new bits to the end of the list.

Example

use scale_bits::{ bits::Bits, bits };

let mut bs = Bits::new();
bs.push(true);
bs.push(false);
bs.push(true);

assert_eq!(bs, bits![1,0,1]);

pub fn pop(&mut self) -> Option<bool>

Remove bits from the end of the list, returning them if they are present.

Example

use scale_bits::{ bits::Bits, bits };

let mut bs = bits![true, false, true, true];
assert_eq!(bs.pop(), Some(true));
assert_eq!(bs.pop(), Some(true));
assert_eq!(bs.pop(), Some(false));
assert_eq!(bs.pop(), Some(true));
assert_eq!(bs.pop(), None);
assert_eq!(bs.pop(), None);

pub fn get(&self, idx: usize) -> Option<bool>

Retrieve a bit at a given index, returning None if no bit exists at that index.

Example

use scale_bits::bits;

let bs = bits![true, false, true, true];
assert_eq!(bs.get(0), Some(true));
assert_eq!(bs.get(1), Some(false));
assert_eq!(bs.get(2), Some(true));
assert_eq!(bs.get(3), Some(true));
assert_eq!(bs.get(4), None);

pub fn iter(&self) -> BitsIter<'_>

Iterate over each bit in order, returning true or false for each.

Example

use scale_bits::bits;

let bs = bits![true, false, true, true];

let v: Vec<bool> = bs.iter().collect();
assert_eq!(v, vec![true, false, true, true]);

pub fn to_vec(self) -> Vec<bool>

Convert our bits into a Vec<bool>.

Example

use scale_bits::bits;

let bs = bits![true, false, true, true].to_vec();
assert_eq!(bs, vec![true, false, true, true]);

Trait Implementations

impl Clone for Bits

fn clone(&self) -> Bits

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bits

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

Formats the value using the given formatter.

impl Decode for Bits

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error>where
    I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for Bits

fn default() -> Bits

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Bits

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Bits

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn encoded_size(&self) -> usize

Calculates the encoded size.

fn encode_to<T>(&self, dest: &mut T)where
    T: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

impl FromIterator<bool> for Bits

fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self

Creates a value from an iterator.

impl IntoIterator for Bits

type Item = bool

The type of the elements being iterated over.

type IntoIter = BitsIntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<Bits> for Bits

fn eq(&self, other: &Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Bits

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for Bits

type Identity = Bits

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Eq for Bits

impl StructuralEq for Bits

impl StructuralPartialEq for Bits