Struct BitSequence

pub struct BitSequence { /* 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() -> Bits

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

pub fn with_capacity(num_bits: usize) -> Bits

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 duplicate 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<(), Error>

Formats the value using the given formatter.

impl Decode for Bits

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

where I: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

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<Bits, <D as Deserializer<'de>>::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) -> R

where F: FnOnce(&[u8]) -> R,

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

impl EncodeAsType for Bits

fn encode_as_type_to<R>( &self, type_id: <R as TypeResolver>::TypeId, types: &R, out: &mut Vec<u8>, ) -> Result<(), Error>

where R: TypeResolver,

Given some type_id, types, a context and some output target for the SCALE encoded bytes, attempt to SCALE encode the current value into the type given by type_id.

fn encode_as_type<R>( &self, type_id: <R as TypeResolver>::TypeId, types: &R, ) -> Result<Vec<u8>, Error>

where R: TypeResolver,

This is a helper function which internally calls EncodeAsType::encode_as_type_to. Prefer to implement that instead.

impl From<Bits> for Value<()>

fn from(val: BitSequence) -> Self

Converts to this type from the input type.

impl<T> From<Bits> for ValueDef<T>

fn from(val: BitSequence) -> Self

Converts to this type from the input type.

impl FromIterator<bool> for Bits

fn from_iter<T>(iter: T) -> Bits

where T: IntoIterator<Item = bool>,

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) -> <Bits as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoVisitor for Bits

type AnyVisitor<R: TypeResolver> = BasicVisitor<Bits, R>

The visitor type used to decode SCALE encoded bytes to Self.

fn into_visitor<R>() -> <Bits as IntoVisitor>::AnyVisitor<R>

where R: TypeResolver,

A means of obtaining this visitor.

impl PartialEq for Bits

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

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::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 StructuralPartialEq for Bits