bitvec 0.19.6

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

/*! `bitvec` symbol export

This module collects the general public API into a single spot for inclusion, as
`use bitvec::prelude::*;`, without polluting the root namespace of the crate.

The prelude has a number of submodules, which can be used to limit the symbols
imported.

The `base` module (`use bitvec::prelude::base::*;`) imports only the data types
and macros needed to make direct use of the crate. It also imports trait
*methods* from `BitField` and `BitView`, without importing those trait names.

The `macros` module imports only the constructor macros.

The `traits` module imports the names of all traits in the crate.

The `types` module imports all data types in the crate.

You may alternatively wish to import the crate root, or this prelude, under a
shorter name, without bringing any other items into scope. The import statements

```rust,ignore
use bitvec as bv;
//  or
use bitvec::prelude as bv;
```

will make the crate symbols available under the `bv` namespace instead of the
longer `bitvec`. The prelude contains all the major public symbols of the crate
directly, while the crate root does not reëxport the items in its submodules.
Use whichever path root you prefer: crate for full paths, and prelude for
shortcuts.
!*/

/// The base symbols, containing only the minimum needed to use the crate.
pub mod base {
	pub use super::{
		macros::*,
		trait_methods::*,
	};

	pub use crate::{
		array::BitArray,
		order::{
			LocalBits,
			Lsb0,
			Msb0,
		},
		slice::BitSlice,
	};

	#[cfg(feature = "alloc")]
	pub use crate::{
		boxed::BitBox,
		vec::BitVec,
	};
}

/// Macros available for default export.
pub mod macros {
	pub use crate::{
		bitarr,
		bits,
	};

	#[cfg(feature = "alloc")]
	pub use crate::{
		bitbox,
		bitvec,
	};
}

/// Traits available for default export.
pub mod traits {
	pub use crate::{
		field::BitField,
		mem::BitMemory,
		order::BitOrder,
		store::BitStore,
		view::BitView,
	};
}

/// Imports trait methods without importing the traits themselves.
pub mod trait_methods {
	pub use crate::{
		field::BitField as _,
		view::BitView as _,
	};
}

/// Datatypes available for default export.
pub mod types {
	pub use crate::{
		array::BitArray,
		domain::{
			BitDomain,
			BitDomainMut,
		},
		order::{
			LocalBits,
			Lsb0,
			Msb0,
		},
		slice::BitSlice,
	};

	#[cfg(feature = "alloc")]
	pub use crate::{
		boxed::BitBox,
		vec::BitVec,
	};
}

pub use macros::*;
pub use traits::*;
pub use types::*;