bitvec 0.2.0

A crate for manipulating memory, bit by bit
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

/// Construct a `BitVec` out of a literal array in source code, analagous to
/// `vec!`.
///
/// `bitvec!` can be invoked in a number of ways. It takes the name of an
/// `Endian` implementation, the name of a `Bits`-implementing primitive, and
/// zero or more primitives (integer, floating-point, or bool) which are used to
/// build the bits. Each primitive literal corresponds to one bit, and is
/// considered to represent 1 if *any* bit in the representation is set.
///
/// `bitvec!` can be invoked with no specifiers, and `Endian` specifier, or an
/// `Endian` and a `Bits` specifier. It cannot be invoked with a `Bits`
/// specifier but no `Endian` specifier, due to overlap in how those tokens are
/// matched by the macro system.
///
/// Like `vec!`, `bitvec!` supports bit lists `[0, 1, ...]` and repetition
/// markers `[1; n]`.
///
/// # All Syntaxes
///
/// ```rust
/// # use bitvec::*;
/// bitvec![BigEndian, u8; 0, 1];
/// bitvec![LittleEndian, u8; 0, 1,];
/// bitvec![BigEndian; 0, 1];
/// bitvec![LittleEndian; 0, 1,];
/// bitvec![0, 1];
/// bitvec![0, 1,];
/// bitvec![BigEndian, u8; 1; 5];
/// bitvec![LittleEndian; 0; 5];
/// bitvec![1; 5];
/// ```
#[macro_export]
macro_rules! bitvec {
	//  bitvec![endian, type ; 0, 1, ...]
	( $end:ident , $prim:ty ; $( $elt:expr ),* ) => {
		__bitvec_impl![ $end, $prim ; $( $elt ),* ]
	};
	//  bitvec![endian, type ; 0, 1, ..., ]
	( $end:ident , $prim:ty ; $( $elt:expr , )* ) => {
		__bitvec_impl![ $end , $prim ; $( $elt ),* ]
	};
	//  bitvec![endian ; 0, 1, ...]
	( $end:ident ; $( $elt:expr ),* ) => {
		__bitvec_impl![ $end , u8 ; $( $elt ),* ]
	};
	//  bitvec![endian ; 0, 1, ..., ]
	( $end:ident ; $( $elt:expr , )* ) => {
		__bitvec_impl![ $end , u8 ; $( $elt ),* ]
	};
	//  bitvec![0, 1, ...]
	( $( $elt:expr ),* ) => {
		__bitvec_impl![ BigEndian , u8 ; $($elt),* ]
	};
	//  bitvec![0, 1, ..., ]
	( $( $elt:expr , )* ) => {
		__bitvec_impl![ BigEndian , u8 ; $($elt),* ]
	};

	//  bitvec![endian, type, bit; rep]
	( $end:ident , $prim:ty ; $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ $end , $prim ; $elt; $rep ]
	};
	//  bitvec![endian, bit; rep]
	( $end:ident ; $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ $end , u8 ;  $elt; $rep ]
	};
	//  bitvec![bit; rep]
	( $elt:expr ; $rep:expr ) => {
		__bitvec_impl![ BigEndian, u8 ; $elt; $rep ]
	};
}

/// Build an array of `bool` (one bit per byte) and then build a `BitVec` from that (one
/// bit per bit). I have yet to think of a way to make the source array be
/// binary-compatible with a `BitVec` representation, so the static source is 8x larger
/// than it needs to be.
///
/// I'm sure there is a way, but I don’t think I need to spend the effort yet.
#[macro_export]
#[doc(hidden)]
macro_rules! __bitvec_impl {
	( $end:ident , $prim:ty ; $( $elt:expr ),* ) => {{
		let init: &[bool] = &[
			$( $elt as u8 > 0 ),*
		];
		$crate :: BitVec ::< $crate :: $end , $prim >:: from(init)
	}};

	( $end:ident , $prim:ty ; $elt:expr; $rep:expr ) => {{
		::std::iter::repeat( $elt as u8 > 0 )
			.take( $rep )
			.collect ::< $crate :: BitVec < $crate :: $end , $prim > > ()
	}};
}

#[cfg(test)]
mod tests {
	#[test]
	fn compile_macros() {
		bitvec![0, 1];
		bitvec![BigEndian; 0, 1];
		bitvec![LittleEndian; 0, 1];
		bitvec![BigEndian, u8; 0, 1];
		bitvec![LittleEndian, u8; 0, 1];
		bitvec![BigEndian, u16; 0, 1];
		bitvec![LittleEndian, u16; 0, 1];
		bitvec![BigEndian, u32; 0, 1];
		bitvec![LittleEndian, u32; 0, 1];
		bitvec![BigEndian, u64; 0, 1];
		bitvec![LittleEndian, u64; 0, 1];

		bitvec![1; 70];
		bitvec![BigEndian; 0; 70];
		bitvec![LittleEndian; 1; 70];
		bitvec![BigEndian, u8; 0; 70];
		bitvec![LittleEndian, u8; 1; 70];
		bitvec![BigEndian, u16; 0; 70];
		bitvec![LittleEndian, u16; 1; 70];
		bitvec![BigEndian, u32; 0; 70];
		bitvec![LittleEndian, u32; 1; 70];
		bitvec![BigEndian, u64; 0; 70];
		bitvec![LittleEndian, u64; 1; 70];
	}
}