endbyte 0.1.0

A no_std compatible rust library for handling byte order conversions between different endianness formats.
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

# endbyte

a no_std compatible rust library for handling byte order conversions between different endianness formats.

## features

- **no_std compatible**: works in embedded environments without the standard library
- **zero dependencies**: no external crates required
- **comprehensive type support**: supports all standard integer types (u8, u16, u32, u64, u128, i8, i16, i32, i64, i128)
- **efficient**: uses rust's built-in `swap_bytes()` methods for optimal performance
- **compile-time endianness detection**: zero runtime overhead for endianness checks
- **well tested**: comprehensive test suite including embedded target testing

## usage

add this to your `Cargo.toml`:

```toml
[dependencies]
endbyte = "0.1.0"
```

### basic usage

```rust
use endbyte::Endianness;

let value = 0x1234u16;

// convert to specific endianness
let big_endian = value.host_to_big_endian();
let little_endian = value.host_to_little_endian();

// convert from specific endianness back to host
let from_big = big_endian.big_endian_to_host();
let from_little = little_endian.little_endian_to_host();

assert_eq!(from_big, value);
assert_eq!(from_little, value);
```

### embedded usage

this library is designed to work in no_std environments:

```rust,ignore
#![no_std]

use endbyte::Endianness;

fn process_network_data(data: u32) -> u32 {
    // convert from network byte order (big endian) to host
    let host_value = data.big_endian_to_host();

    // process the value...
    let result = host_value * 2;

    // convert back to network byte order
    result.host_to_big_endian()
}
```

## supported types

the `Endianness` trait is implemented for all standard integer types:

- unsigned: `u8`, `u16`, `u32`, `u64`, `u128`
- signed: `i8`, `i16`, `i32`, `i64`, `i128`

note: single-byte types (`u8`, `i8`) have zero-cost implementations since byte swapping is not needed.

## methods

- `host_to_big_endian()`: convert from host byte order to big endian
- `host_to_little_endian()`: convert from host byte order to little endian
- `big_endian_to_host()`: convert from big endian to host byte order
- `little_endian_to_host()`: convert from little endian to host byte order

## performance

this library is designed for maximum performance:

- uses rust's built-in `swap_bytes()` methods which compile to optimal assembly
- compile-time endianness detection means zero runtime overhead
- single-byte types have zero-cost implementations
- all methods are marked `#[inline]` for optimal inlining

## testing

the library includes comprehensive tests that work on both big and little endian systems:

```bash
cargo test
```

for embedded targets:

```bash
cargo build --target thumbv7em-none-eabihf
cargo build --target thumbv6m-none-eabi
```

## license

this project is licensed under the mit license - see the license file for details.