2018-07-12 04:59:50 +00:00
|
|
|
/*
|
|
|
|
* Implemenation of a bitfield as a vec. Only
|
|
|
|
* supports bytes (Vec<u8>) as the underlying
|
|
|
|
* storage.
|
|
|
|
*
|
|
|
|
* A future implementation should be more efficient,
|
|
|
|
* this is just to get the job done for now.
|
|
|
|
*/
|
2018-09-22 04:07:14 +00:00
|
|
|
extern crate ssz;
|
|
|
|
|
2018-07-16 06:34:34 +00:00
|
|
|
use std::cmp::max;
|
2018-07-12 04:59:50 +00:00
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
#[derive(Eq, Clone, Default, Debug)]
|
2018-07-12 04:59:50 +00:00
|
|
|
pub struct BooleanBitfield{
|
2018-07-16 06:34:34 +00:00
|
|
|
len: usize,
|
2018-07-12 04:59:50 +00:00
|
|
|
vec: Vec<u8>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl BooleanBitfield {
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Create a new bitfield with a length of zero.
|
2018-07-12 04:59:50 +00:00
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
2018-07-16 06:34:34 +00:00
|
|
|
len: 0,
|
2018-09-19 06:45:32 +00:00
|
|
|
vec: vec![0]
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
}
|
2018-09-10 05:50:35 +00:00
|
|
|
|
|
|
|
/// Create a new bitfield of a certain capacity
|
2018-07-12 04:59:50 +00:00
|
|
|
pub fn with_capacity(capacity: usize) -> Self {
|
2018-09-19 06:45:32 +00:00
|
|
|
let mut vec = Vec::with_capacity(capacity / 8 + 1);
|
|
|
|
vec.push(0);
|
2018-07-12 04:59:50 +00:00
|
|
|
Self {
|
2018-07-16 06:34:34 +00:00
|
|
|
len: 0,
|
2018-09-19 06:45:32 +00:00
|
|
|
vec
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Read the value of a bit.
|
|
|
|
///
|
|
|
|
/// Will return `true` if the bit has been set to `true`
|
|
|
|
/// without then being set to `False`.
|
2018-09-22 04:07:14 +00:00
|
|
|
pub fn get_bit(&self, i: usize) -> bool {
|
|
|
|
let bit = |i: usize| i % 8;
|
|
|
|
let byte = |i: usize| i / 8;
|
2018-07-12 04:59:50 +00:00
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
if byte(i) >= self.vec.len() {
|
2018-07-12 04:59:50 +00:00
|
|
|
false
|
|
|
|
} else {
|
2018-09-10 05:50:35 +00:00
|
|
|
self.vec[byte(i)] & (1 << (bit(i) as u8)) != 0
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Set the value of a bit.
|
|
|
|
///
|
|
|
|
/// If this bit is larger than the length of the underlying byte
|
|
|
|
/// array it will be extended.
|
2018-09-22 04:07:14 +00:00
|
|
|
pub fn set_bit(&mut self, i: usize, to: bool) {
|
|
|
|
let bit = |i: usize| i % 8;
|
|
|
|
let byte = |i: usize| i / 8;
|
2018-09-10 05:50:35 +00:00
|
|
|
|
|
|
|
self.len = max(self.len, i + 1);
|
2018-07-12 04:59:50 +00:00
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
if byte(i) >= self.vec.len() {
|
|
|
|
self.vec.resize(byte(i) + 1, 0);
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
2018-09-22 04:07:14 +00:00
|
|
|
if to {
|
|
|
|
self.vec[byte(i)] =
|
|
|
|
self.vec[byte(i)] | (1 << (bit(i) as u8))
|
|
|
|
} else {
|
|
|
|
self.vec[byte(i)] =
|
|
|
|
self.vec[byte(i)] & !(1 << (bit(i) as u8))
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
}
|
2018-07-12 08:19:20 +00:00
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Return the "length" of this bitfield. Length is defined as
|
|
|
|
/// the highest bit that has been set.
|
|
|
|
///
|
|
|
|
/// Note: this is distinct from the length of the underlying
|
|
|
|
/// vector.
|
2018-07-16 06:34:34 +00:00
|
|
|
pub fn len(&self) -> usize { self.len }
|
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
/// True if no bits have ever been set. A bit that is set and then
|
|
|
|
/// unset will still count to the length of the bitfield.
|
|
|
|
///
|
|
|
|
/// Note: this is distinct from the length of the underlying
|
|
|
|
/// vector.
|
|
|
|
pub fn is_empty(&self) -> bool { self.len == 0 }
|
|
|
|
|
2018-09-22 11:58:54 +00:00
|
|
|
/// The number of bytes required to represent the bitfield.
|
|
|
|
pub fn num_bytes(&self) -> usize { self.vec.len() }
|
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Iterate through the underlying vector and count the number of
|
|
|
|
/// true bits.
|
2018-07-12 08:53:11 +00:00
|
|
|
pub fn num_true_bits(&self) -> u64 {
|
2018-07-12 08:19:20 +00:00
|
|
|
let mut count: u64 = 0;
|
|
|
|
for byte in &self.vec {
|
|
|
|
for bit in 0..8 {
|
|
|
|
if byte & (1 << (bit as u8)) != 0 {
|
|
|
|
count += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
count
|
|
|
|
}
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
/// Iterate through the underlying vector and find the highest
|
|
|
|
/// set bit. Useful for instantiating a new instance from
|
|
|
|
/// some set of bytes.
|
|
|
|
pub fn compute_length(bytes: &[u8]) -> usize {
|
|
|
|
for byte in (0..bytes.len()).rev() {
|
|
|
|
for bit in (0..8).rev() {
|
2018-09-30 04:54:03 +00:00
|
|
|
if bytes[byte] & (1 << (bit as u8)) != 0 {
|
|
|
|
return (byte * 8) + bit + 1
|
2018-09-22 04:07:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
0
|
|
|
|
}
|
|
|
|
|
2018-09-24 08:06:47 +00:00
|
|
|
/// Get the byte at a position, assuming big-endian encoding.
|
|
|
|
pub fn get_byte(&self, n: usize) -> Option<&u8> {
|
|
|
|
self.vec.get(n)
|
|
|
|
}
|
|
|
|
|
2018-09-10 05:50:35 +00:00
|
|
|
/// Clone and return the underlying byte array (`Vec<u8>`).
|
2018-09-25 12:09:30 +00:00
|
|
|
pub fn to_vec(&self) -> Vec<u8> {
|
|
|
|
self.vec.clone()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Clone and return the underlying byte array (`Vec<u8>`) in big-endinan format.
|
2018-09-10 06:51:51 +00:00
|
|
|
pub fn to_be_vec(&self) -> Vec<u8> {
|
2018-09-10 05:50:35 +00:00
|
|
|
let mut o = self.vec.clone();
|
|
|
|
o.reverse();
|
|
|
|
o
|
|
|
|
}
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
impl<'a> From<&'a [u8]> for BooleanBitfield {
|
|
|
|
fn from(input: &[u8]) -> Self {
|
|
|
|
let mut vec = input.to_vec();
|
|
|
|
vec.reverse();
|
|
|
|
BooleanBitfield {
|
|
|
|
vec,
|
|
|
|
len: BooleanBitfield::compute_length(input)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-17 03:21:28 +00:00
|
|
|
impl PartialEq for BooleanBitfield {
|
|
|
|
fn eq(&self, other: &BooleanBitfield) -> bool {
|
|
|
|
(self.vec == other.vec) &
|
|
|
|
(self.len == other.len)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
impl ssz::Encodable for BooleanBitfield {
|
|
|
|
fn ssz_append(&self, s: &mut ssz::SszStream) {
|
2018-09-25 12:09:30 +00:00
|
|
|
s.append_vec(&self.to_vec());
|
2018-09-22 04:07:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ssz::Decodable for BooleanBitfield {
|
|
|
|
fn ssz_decode(bytes: &[u8], index: usize)
|
|
|
|
-> Result<(Self, usize), ssz::DecodeError>
|
|
|
|
{
|
|
|
|
let len = ssz::decode::decode_length(
|
|
|
|
bytes,
|
|
|
|
index,
|
|
|
|
ssz::LENGTH_BYTES)?;
|
|
|
|
if (ssz::LENGTH_BYTES + len) > bytes.len() {
|
|
|
|
return Err(ssz::DecodeError::TooShort);
|
|
|
|
}
|
|
|
|
if len == 0 {
|
|
|
|
Ok((BooleanBitfield::new(),
|
|
|
|
index + ssz::LENGTH_BYTES))
|
|
|
|
} else {
|
2018-09-22 05:52:10 +00:00
|
|
|
let b = BooleanBitfield::
|
|
|
|
from(&bytes[(index + 4)..(index + len + 4)]);
|
2018-09-22 04:07:14 +00:00
|
|
|
let index = index + ssz::LENGTH_BYTES + len;
|
|
|
|
Ok((b, index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-17 03:21:28 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
2018-09-22 04:07:14 +00:00
|
|
|
use ssz::Decodable;
|
|
|
|
|
2018-09-30 04:54:03 +00:00
|
|
|
#[test]
|
|
|
|
fn test_new_from_slice() {
|
|
|
|
let s = [0];
|
|
|
|
let b = BooleanBitfield::from(&s[..]);
|
|
|
|
assert_eq!(b.len, 0);
|
|
|
|
|
|
|
|
let s = [255];
|
|
|
|
let b = BooleanBitfield::from(&s[..]);
|
|
|
|
assert_eq!(b.len, 8);
|
|
|
|
|
|
|
|
let s = [0, 1];
|
|
|
|
let b = BooleanBitfield::from(&s[..]);
|
|
|
|
assert_eq!(b.len, 9);
|
|
|
|
|
|
|
|
let s = [31];
|
|
|
|
let b = BooleanBitfield::from(&s[..]);
|
|
|
|
assert_eq!(b.len, 5);
|
|
|
|
}
|
|
|
|
|
2018-09-22 04:07:14 +00:00
|
|
|
#[test]
|
|
|
|
fn test_ssz_encoding() {
|
|
|
|
let mut b = BooleanBitfield::new();
|
|
|
|
b.set_bit(8, true);
|
|
|
|
|
|
|
|
let mut stream = ssz::SszStream::new();
|
|
|
|
stream.append(&b);
|
|
|
|
|
2018-09-25 12:09:30 +00:00
|
|
|
assert_eq!(stream.drain(), vec![0, 0, 0, 2, 0, 1]);
|
2018-09-22 04:07:14 +00:00
|
|
|
}
|
|
|
|
|
2018-10-02 06:41:10 +00:00
|
|
|
/*
|
2018-09-22 04:07:14 +00:00
|
|
|
#[test]
|
|
|
|
fn test_ssz_decoding() {
|
|
|
|
/*
|
|
|
|
* Correct input
|
|
|
|
*/
|
2018-09-25 12:09:30 +00:00
|
|
|
let input = vec![0, 0, 0, 2, 0, 1];
|
2018-09-22 04:07:14 +00:00
|
|
|
let (b, i) = BooleanBitfield::ssz_decode(&input, 0).unwrap();
|
|
|
|
assert_eq!(i, 6);
|
|
|
|
assert_eq!(b.num_true_bits(), 1);
|
|
|
|
assert_eq!(b.get_bit(8), true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Input too long
|
|
|
|
*/
|
2018-09-25 12:09:30 +00:00
|
|
|
let mut input = vec![0, 0, 0, 2, 0, 1];
|
2018-09-22 04:07:14 +00:00
|
|
|
input.push(42);
|
|
|
|
let (b, i) = BooleanBitfield::ssz_decode(&input, 0).unwrap();
|
|
|
|
assert_eq!(i, 6);
|
|
|
|
assert_eq!(b.num_true_bits(), 1);
|
|
|
|
assert_eq!(b.get_bit(8), true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Input too short
|
|
|
|
*/
|
|
|
|
let input = vec![0, 0, 0, 2, 1];
|
|
|
|
let res = BooleanBitfield::ssz_decode(&input, 0);
|
|
|
|
assert_eq!(res, Err(ssz::DecodeError::TooShort));
|
|
|
|
}
|
2018-10-02 06:41:10 +00:00
|
|
|
*/
|
2018-09-22 04:07:14 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_new_bitfield_len() {
|
|
|
|
let b = BooleanBitfield::new();
|
|
|
|
assert_eq!(b.len(), 0);
|
|
|
|
assert_eq!(b.to_be_vec(), vec![0]);
|
|
|
|
|
|
|
|
let b = BooleanBitfield::with_capacity(100);
|
|
|
|
assert_eq!(b.len(), 0);
|
|
|
|
assert_eq!(b.to_be_vec(), vec![0]);
|
|
|
|
}
|
2018-07-12 04:59:50 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bitfield_set() {
|
|
|
|
let mut b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(0, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [0]);
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(7, true);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [128]);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(7, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [0]);
|
2018-07-16 06:34:34 +00:00
|
|
|
assert_eq!(b.len(), 8);
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(7, true);
|
|
|
|
b.set_bit(0, true);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [129]);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(7, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [1]);
|
2018-07-16 06:34:34 +00:00
|
|
|
assert_eq!(b.len(), 8);
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(8, true);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [1, 0]);
|
2018-09-10 05:50:35 +00:00
|
|
|
assert_eq!(b.len(), 9);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(8, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [0, 0]);
|
2018-07-16 06:34:34 +00:00
|
|
|
assert_eq!(b.len(), 9);
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(15, true);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [128, 0]);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(15, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [0, 0]);
|
2018-07-16 06:34:34 +00:00
|
|
|
assert_eq!(b.len(), 16);
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 04:59:50 +00:00
|
|
|
b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(8, true);
|
|
|
|
b.set_bit(15, true);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [129, 0]);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(15, false);
|
2018-09-10 06:51:51 +00:00
|
|
|
assert_eq!(b.to_be_vec(), [1, 0]);
|
2018-07-16 06:34:34 +00:00
|
|
|
assert_eq!(b.len(), 16);
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_bitfield_get() {
|
|
|
|
let test_nums = vec![0, 8, 15, 42, 1337];
|
|
|
|
for i in test_nums {
|
2018-07-12 07:50:02 +00:00
|
|
|
let mut b = BooleanBitfield::new();
|
2018-09-22 04:07:14 +00:00
|
|
|
assert_eq!(b.get_bit(i), false);
|
|
|
|
b.set_bit(i, true);
|
|
|
|
assert_eq!(b.get_bit(i), true);
|
|
|
|
b.set_bit(i, true);
|
2018-09-10 05:50:35 +00:00
|
|
|
}
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|
2018-09-10 05:50:35 +00:00
|
|
|
|
2018-07-12 08:19:20 +00:00
|
|
|
#[test]
|
|
|
|
fn test_bitfield_num_true_bits() {
|
|
|
|
let mut b = BooleanBitfield::new();
|
|
|
|
assert_eq!(b.num_true_bits(), 0);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(15, true);
|
2018-07-12 08:19:20 +00:00
|
|
|
assert_eq!(b.num_true_bits(), 1);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(15, false);
|
2018-07-12 08:19:20 +00:00
|
|
|
assert_eq!(b.num_true_bits(), 0);
|
2018-09-22 04:07:14 +00:00
|
|
|
b.set_bit(0, true);
|
|
|
|
b.set_bit(7, true);
|
|
|
|
b.set_bit(8, true);
|
|
|
|
b.set_bit(1337, true);
|
2018-07-12 08:19:20 +00:00
|
|
|
assert_eq!(b.num_true_bits(), 4);
|
|
|
|
}
|
2018-07-12 04:59:50 +00:00
|
|
|
}
|