Struct sqlx::types::BitVec

pub struct BitVec<B = u32> { /* fields omitted */ }

The bitvector type.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(10, false);

// insert all primes less than 10
bv.set(2, true);
bv.set(3, true);
bv.set(5, true);
bv.set(7, true);
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// flip all values in bitvector, producing non-primes less than 10
bv.negate();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

// reset bitvector to empty
bv.clear();
println!("{:?}", bv);
println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());

Implementations

impl BitVec<u32>

pub fn new() -> BitVec<u32>

Creates an empty BitVec.

Examples

use bit_vec::BitVec;
let mut bv = BitVec::new();

pub fn from_elem(nbits: usize, bit: bool) -> BitVec<u32>

Creates a BitVec that holds nbits elements, setting each element to bit.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.len(), 10);
for x in bv.iter() {
    assert_eq!(x, false);
}

pub fn with_capacity(nbits: usize) -> BitVec<u32>

Constructs a new, empty BitVec with the specified capacity.

The bitvector will be able to hold at least capacity bits without reallocating. If capacity is 0, it will not allocate.

It is important to note that this function does not specify the length of the returned bitvector, but only the capacity.

pub fn from_bytes(bytes: &[u8]) -> BitVec<u32>

Transforms a byte-vector into a BitVec. Each byte becomes eight bits, with the most significant bits of each byte coming first. Each bit becomes true if equal to 1 or false if equal to 0.

Examples

use bit_vec::BitVec;

let bv = BitVec::from_bytes(&[0b10100000, 0b00010010]);
assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false,
                    false, false, false, true,
                    false, false, true, false]));

pub fn from_fn<F>(len: usize, f: F) -> BitVec<u32> where
    F: FnMut(usize) -> bool, 

Creates a BitVec of the specified length where the value at each index is f(index).

Examples

use bit_vec::BitVec;

let bv = BitVec::from_fn(5, |i| { i % 2 == 0 });
assert!(bv.eq_vec(&[true, false, true, false, true]));

impl<B> BitVec<B> where
    B: BitBlock, 

pub fn blocks(&self) -> Blocks<'_, B>

Iterator over the underlying blocks of data

pub fn storage(&self) -> &[B]

Exposes the raw block storage of this BitVec

Only really intended for BitSet.

pub unsafe fn storage_mut(&mut self) -> &mut Vec<B, Global>

Exposes the raw block storage of this BitVec

Can probably cause unsafety. Only really intended for BitSet.

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

Retrieves the value at index i, or None if the index is out of bounds.

Examples

use bit_vec::BitVec;

let bv = BitVec::from_bytes(&[0b01100000]);
assert_eq!(bv.get(0), Some(false));
assert_eq!(bv.get(1), Some(true));
assert_eq!(bv.get(100), None);

// Can also use array indexing
assert_eq!(bv[1], true);

pub fn set(&mut self, i: usize, x: bool)

Sets the value of a bit at an index i.

Panics

Panics if i is out of bounds.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(5, false);
bv.set(3, true);
assert_eq!(bv[3], true);

pub fn set_all(&mut self)

Sets all bits to 1.

Examples

use bit_vec::BitVec;

let before = 0b01100000;
let after  = 0b11111111;

let mut bv = BitVec::from_bytes(&[before]);
bv.set_all();
assert_eq!(bv, BitVec::from_bytes(&[after]));

pub fn negate(&mut self)

Flips all bits.

Examples

use bit_vec::BitVec;

let before = 0b01100000;
let after  = 0b10011111;

let mut bv = BitVec::from_bytes(&[before]);
bv.negate();
assert_eq!(bv, BitVec::from_bytes(&[after]));

pub fn union(&mut self, other: &BitVec<B>) -> bool

👎 Deprecated since 0.7.0:

Please use the ‘or’ function instead

Calculates the union of two bitvectors. This acts like the bitwise or function.

Sets self to the union of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

use bit_vec::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01111110;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.union(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn intersect(&mut self, other: &BitVec<B>) -> bool

👎 Deprecated since 0.7.0:

Please use the ‘and’ function instead

Calculates the intersection of two bitvectors. This acts like the bitwise and function.

Sets self to the intersection of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

use bit_vec::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01000000;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.intersect(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn or(&mut self, other: &BitVec<B>) -> bool

Calculates the bitwise or of two bitvectors.

Sets self to the union of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

use bit_vec::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01111110;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.or(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn and(&mut self, other: &BitVec<B>) -> bool

Calculates the bitwise and of two bitvectors.

Sets self to the intersection of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different lengths.

Examples

use bit_vec::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let res = 0b01000000;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.and(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn difference(&mut self, other: &BitVec<B>) -> bool

Calculates the difference between two bitvectors.

Sets each element of self to the value of that element minus the element of other at the same index. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

use bit_vec::BitVec;

let a   = 0b01100100;
let b   = 0b01011010;
let a_b = 0b00100100; // a - b
let b_a = 0b00011010; // b - a

let mut bva = BitVec::from_bytes(&[a]);
let bvb = BitVec::from_bytes(&[b]);

assert!(bva.difference(&bvb));
assert_eq!(bva, BitVec::from_bytes(&[a_b]));

let bva = BitVec::from_bytes(&[a]);
let mut bvb = BitVec::from_bytes(&[b]);

assert!(bvb.difference(&bva));
assert_eq!(bvb, BitVec::from_bytes(&[b_a]));

pub fn xor(&mut self, other: &BitVec<B>) -> bool

Calculates the xor of two bitvectors.

Sets self to the xor of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

use bit_vec::BitVec;

let a   = 0b01100110;
let b   = 0b01010100;
let res = 0b00110010;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.xor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn nand(&mut self, other: &BitVec<B>) -> bool

Calculates the nand of two bitvectors.

Sets self to the nand of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

use bit_vec::BitVec;

let a   = 0b01100110;
let b   = 0b01010100;
let res = 0b10111011;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.nand(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn nor(&mut self, other: &BitVec<B>) -> bool

Calculates the nor of two bitvectors.

Sets self to the nor of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

use bit_vec::BitVec;

let a   = 0b01100110;
let b   = 0b01010100;
let res = 0b10001001;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.nor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn xnor(&mut self, other: &BitVec<B>) -> bool

Calculates the xnor of two bitvectors.

Sets self to the xnor of self and other. Both bitvectors must be the same length. Returns true if self changed.

Panics

Panics if the bitvectors are of different length.

Examples

use bit_vec::BitVec;

let a   = 0b01100110;
let b   = 0b01010100;
let res = 0b11001101;

let mut a = BitVec::from_bytes(&[a]);
let b = BitVec::from_bytes(&[b]);

assert!(a.xnor(&b));
assert_eq!(a, BitVec::from_bytes(&[res]));

pub fn all(&self) -> bool

Returns true if all bits are 1.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(5, true);
assert_eq!(bv.all(), true);

bv.set(1, false);
assert_eq!(bv.all(), false);

pub fn iter(&self) -> Iter<'_, B>

Returns an iterator over the elements of the vector in order.

Examples

use bit_vec::BitVec;

let bv = BitVec::from_bytes(&[0b01110100, 0b10010010]);
assert_eq!(bv.iter().filter(|x| *x).count(), 7);

pub fn append(&mut self, other: &mut BitVec<B>)

Moves all bits from other into Self, leaving other empty.

Examples

use bit_vec::BitVec;

let mut a = BitVec::from_bytes(&[0b10000000]);
let mut b = BitVec::from_bytes(&[0b01100001]);

a.append(&mut b);

assert_eq!(a.len(), 16);
assert_eq!(b.len(), 0);
assert!(a.eq_vec(&[true, false, false, false, false, false, false, false,
                   false, true, true, false, false, false, false, true]));

pub fn split_off(&mut self, at: usize) -> BitVec<B>

Splits the BitVec into two at the given bit, retaining the first half in-place and returning the second one.

Panics

Panics if at is out of bounds.

Examples

use bit_vec::BitVec;
let mut a = BitVec::new();
a.push(true);
a.push(false);
a.push(false);
a.push(true);

let b = a.split_off(2);

assert_eq!(a.len(), 2);
assert_eq!(b.len(), 2);
assert!(a.eq_vec(&[true, false]));
assert!(b.eq_vec(&[false, true]));

pub fn none(&self) -> bool

Returns true if all bits are 0.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.none(), true);

bv.set(3, true);
assert_eq!(bv.none(), false);

pub fn any(&self) -> bool

Returns true if any bit is 1.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(10, false);
assert_eq!(bv.any(), false);

bv.set(3, true);
assert_eq!(bv.any(), true);

pub fn to_bytes(&self) -> Vec<u8, Global>

Organises the bits into bytes, such that the first bit in the BitVec becomes the high-order bit of the first byte. If the size of the BitVec is not a multiple of eight then trailing bits will be filled-in with false.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(3, true);
bv.set(1, false);

assert_eq!(bv.to_bytes(), [0b10100000]);

let mut bv = BitVec::from_elem(9, false);
bv.set(2, true);
bv.set(8, true);

assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);

pub fn eq_vec(&self, v: &[bool]) -> bool

Compares a BitVec to a slice of bools. Both the BitVec and slice must have the same length.

Panics

Panics if the BitVec and slice are of different length.

Examples

use bit_vec::BitVec;

let bv = BitVec::from_bytes(&[0b10100000]);

assert!(bv.eq_vec(&[true, false, true, false,
                    false, false, false, false]));

pub fn truncate(&mut self, len: usize)

Shortens a BitVec, dropping excess elements.

If len is greater than the vector’s current length, this has no effect.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001011]);
bv.truncate(2);
assert!(bv.eq_vec(&[false, true]));

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more bits to be inserted in the given BitVec. The collection may reserve more space to avoid frequent reallocations.

Panics

Panics if the new capacity overflows usize.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for exactly additional more bits to be inserted in the given BitVec. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity overflows usize.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_elem(3, false);
bv.reserve(10);
assert_eq!(bv.len(), 3);
assert!(bv.capacity() >= 13);

pub fn capacity(&self) -> usize

Returns the capacity in bits for this bit vector. Inserting any element less than this amount will not trigger a resizing.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::new();
bv.reserve(10);
assert!(bv.capacity() >= 10);

pub fn grow(&mut self, n: usize, value: bool)

Grows the BitVec in-place, adding n copies of value to the BitVec.

Panics

Panics if the new len overflows a usize.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001011]);
bv.grow(2, true);
assert_eq!(bv.len(), 10);
assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]);

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

Removes the last bit from the BitVec, and returns it. Returns None if the BitVec is empty.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::from_bytes(&[0b01001001]);
assert_eq!(bv.pop(), Some(true));
assert_eq!(bv.pop(), Some(false));
assert_eq!(bv.len(), 6);

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

Pushes a bool onto the end.

Examples

use bit_vec::BitVec;

let mut bv = BitVec::new();
bv.push(true);
bv.push(false);
assert!(bv.eq_vec(&[true, false]));

pub fn len(&self) -> usize

Returns the total number of bits in this vector

pub unsafe fn set_len(&mut self, len: usize)

Sets the number of bits that this BitVec considers initialized.

Almost certainly can cause bad stuff. Only really intended for BitSet.

pub fn is_empty(&self) -> bool

Returns true if there are no bits in this vector

pub fn clear(&mut self)

Clears all bits in this vector.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the underlying storage as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the underlying storage that there is space for a few more elements/bits.

Trait Implementations

impl<B> Clone for BitVec<B> where
    B: BitBlock, 

pub fn clone(&self) -> BitVec<B>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &BitVec<B>)

Performs copy-assignment from source.

impl<B> Debug for BitVec<B> where
    B: BitBlock, 

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

Formats the value using the given formatter.

impl<'_> Decode<'_, Postgres> for BitVec<u32>

pub fn decode(
    value: PgValueRef<'_>
) -> Result<BitVec<u32>, Box<dyn Error + 'static + Sync + Send, Global>>

Decode a new value of this type using a raw value from the database.

impl<B> Default for BitVec<B> where
    B: BitBlock, 

pub fn default() -> BitVec<B>

Returns the “default value” for a type.

impl<'_> Encode<'_, Postgres> for BitVec<u32>

pub fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull

Writes the value of self into buf without moving self.

pub fn size_hint(&self) -> usize

#[must_use]

fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

impl<B> Extend<bool> for BitVec<B> where
    B: BitBlock, 

pub fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = bool>, 

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<B> FromIterator<bool> for BitVec<B> where
    B: BitBlock, 

pub fn from_iter<I>(iter: I) -> BitVec<B> where
    I: IntoIterator<Item = bool>, 

Creates a value from an iterator.

impl<B> Hash for BitVec<B> where
    B: BitBlock, 

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<B> Index<usize> for BitVec<B> where
    B: BitBlock, 

type Output = bool

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<B> IntoIterator for BitVec<B> where
    B: BitBlock, 

type Item = bool

The type of the elements being iterated over.

type IntoIter = IntoIter<B>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> IntoIter<B>

Creates an iterator from a value.

impl<'a, B> IntoIterator for &'a BitVec<B> where
    B: BitBlock, 

type Item = bool

The type of the elements being iterated over.

type IntoIter = Iter<'a, B>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Iter<'a, B>

Creates an iterator from a value.

impl<B> Ord for BitVec<B> where
    B: BitBlock, 

pub fn cmp(&self, other: &BitVec<B>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<B> PartialEq<BitVec<B>> for BitVec<B> where
    B: BitBlock, 

pub fn eq(&self, other: &BitVec<B>) -> bool

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

#[must_use]

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

This method tests for !=.

impl<B> PartialOrd<BitVec<B>> for BitVec<B> where
    B: BitBlock, 

pub fn partial_cmp(&self, other: &BitVec<B>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Type<Postgres> for BitVec<u32>

pub fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type.

pub fn compatible(ty: &PgTypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.

impl<B> Eq for BitVec<B> where
    B: BitBlock,