Struct sqlx_oldapi::types::BitVec

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

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,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

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

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

fn default() -> BitVec<B>

Returns the “default value” for a type.

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

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

Writes the value of self into buf without moving self.

fn size_hint(&self) -> usize

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

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,

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,

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,

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, Self: Sized,

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.

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

Performs the indexing (container[index]) operation.

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?

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

Creates an iterator from a value.

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?

fn into_iter(self) -> IntoIter<B>

Creates an iterator from a value.

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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

fn eq(&self, other: &BitVec<B>) -> 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<B> PartialOrd<BitVec<B>> for BitVec<B>where B: BitBlock,

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

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

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

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

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

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

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

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

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 PgHasArrayType for BitVec<u32>

fn array_type_info() -> PgTypeInfo

fn array_compatible(ty: &PgTypeInfo) -> bool

impl Type<Postgres> for BitVec<u32>

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type.

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,