bv 0.11.1

Bit-vectors and bit-slices
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/// Like `vec!` but for [`BitVec`](struct.BitVec.html).
///
/// The `bit_vec!` macro creates a `BitVec` literal. It takes two forms:
///
///   - A single `bool`, followed by a semicolon and number of times to repeat. This is
///     equivalent to a call to [`BitVec::new_fill`](struct.BitVec.html#method.new_fill).
///
///   - A sequence of comma-separated `bool`s; this creates a `BitVec` and pushes each `bool` in
///     turn.
///
/// # Examples
///
/// ```
/// # #[macro_use] extern crate bv;
/// use bv::*;
///
/// fn main() {
///     let mut bv1: BitVec = bit_vec![ true; 3 ];
///     let     bv2: BitVec = bit_vec![ true, false, true ];
///
///     assert_ne!(bv1, bv2);
///     bv1.set_bit(1, false);
///     assert_eq!(bv1, bv2);
/// }
/// ```
#[macro_export]
macro_rules! bit_vec {
    ( $e:expr ; $n:expr ) => {
        $crate::BitVec::new_fill($e, $n)
    };

    ( $( $e:expr ),* ) => {
        {
            let mut result = $crate::BitVec::new();
            let _ = &mut result;
            $(
                result.push($e);
            )*
            result
        }
    };

    ( $( $e:expr, )* ) => {
        bit_vec![ $($e),* ]
    };
}

#[test]
fn bit_vec_macro_allows_trailing_comma() {
    let bv1: super::BitVec = bit_vec![true, false, true];
    let bv2: super::BitVec = bit_vec![true, false, true,];
    assert_eq!( bv1, bv2 );
}

#[test]
fn type_1_hygiene() {
    let result = true;
    let bv: super::BitVec = bit_vec![result];
    assert!( bv[0] );
}

// Implements Index for any type that implements Bits.
macro_rules! impl_index_from_bits {
    (
    $(
        impl[ $($param:tt)* ] Index<$ix:ty> for $bv:ty ;
    )+
    )=> {
        $(
            impl<$($param)*> ::std::ops::Index<$ix> for $bv {
                type Output = bool;

                fn index(&self, index: $ix) -> &bool {
                    use $crate::Bits;

                    static TRUE: bool = true;
                    static FALSE: bool = false;

                    if self.get_bit(index) {&TRUE} else {&FALSE}
                }
            }
        )+
    };
}