Simple bitwise pattern testing for integers.
Provides functionality to compare integers against patterns of bits which include wildcards.
Patterns can be declared with convenient macros, the generated code is incredibly small and
efficient, no_std, and the crate depends only on its bitpatterns-proc-macro, which itself
has zero dependencies.
Bitwise patterns are stored in the [BitPattern] type, which provides the [is_match][BitPattern::is_match] method to
test for matches. The easiest way to create one of these patterns is with the [bitpattern!] macro,
or the [is_bit_match!] macro if the pattern is only being used once.
```rust use bitpatterns::*;
// BitPatterns can be stored as normal variables
let pattern1 = bitpattern!("0b10..1");
// Or even consts
const PATTERN_2: BitPattern
// Now, we can test these patterns against numbers assert!(pattern1.ismatch(19)); // 19 == 0b10011 assert!(!PATTERN2.ismatch(19));
assert!(!pattern1.ismatch(5)); // 5 == 0b00101 assert!(PATTERN2.ismatch(5));
// Any digits which are not part of the pattern string are automatically // treated as wildcards assert!(PATTERN2.ismatch(35)); // 35 == 0b100011
// The isbitmatch macro can be used without declaring a pattern variable assert!(isbitmatch!("101..", 20)); // 20 == 0b10100
// Using an as conversion to compare a number to a pattern of a different
// size/signedness always works, keeping in mind that bits not specified in
// the pattern are considered wildcards
let pattern3 = bitpattern!("1..01", u8);
let x: i16 = 0b0100001010011001;
assert!(pattern3.ismatch(x as u8));
```
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.