bitstructs 0.1.0

Defining type-safe bitfield structures that can be used in both `std` and `no_std` environments.
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

# Bitstructs

`bitstructs` is a library for defining type-safe bitfield structs that can be used in both `std` and `no_std` environments.

## Features

- Type-safe bit operations
- Simple to use and highly flexible
- Supports both `no_std` and `std`
- Implemented using proc-macros with no additional runtime code

## Example

Here is a simple example of using `bitstructs`.

```rust
use bitstructs::{bitstruct_cow};
bitstruct_cow! {
    #[derive(Clone, Debug, PartialEq)]
    pub struct Test {
        a: 1,
        b: 2,
        c: 2 =>
        pub enum C {
            C0 = 0,
            C1 = 1,
        },
    }
}
let mut value = Test::new();
assert_eq!(value.as_bytes(), vec![0b0000_0000]);
value.set_a(true);
unsafe { value.set_b(1) };
value.set_c(C::C1);
assert_eq!(value.as_bytes(), vec![0b0000_1011]);
```

By default, the library uses LSB0 and little-endian mode. To use MSB0 and big-endian mode, add `#[bitstruct_repr(MSB0)]` to the struct.

```rust
use bitstructs::{bitstruct_cow};
/// MSB0 and big-endian
bitstruct_cow! {
    #[derive(Clone, Debug, PartialEq)]
    #[bitstruct_repr(MSB0)]
    pub struct Test {
        a: 1,
        b: 2,
        c: 2 =>
        pub enum C {
            C0 = 0,
            C1 = 1,
        },
    }
}
let mut value = Test::new();
assert_eq!(value.as_bytes(), vec![0b0000_0000]);
value.set_a(true);
unsafe { value.set_b(1) };
value.set_c(C::C1);
assert_eq!(value.as_bytes(), vec![0b1010_1000]);
```

## Documentation

For more information, please refer to the [documentation](https://docs.rs/bitstructs).

## Contribution

Contributions are welcome! Please open an issue or submit a pull request on [GitHub](https://github.com/yourusername/bitstructs).