#no_std

no-std byte-slice-cast

Safely cast bytes slices from/to slices of built-in fundamental numeric types

8 releases

0.3.5 Dec 22, 2019
0.3.4 Nov 11, 2019
0.3.2 Jul 25, 2019
0.3.1 Jun 5, 2019
0.1.0 Aug 14, 2017

#202 in Encoding

Download history 11830/week @ 2020-06-03 13147/week @ 2020-06-10 12839/week @ 2020-06-17 13265/week @ 2020-06-24 12910/week @ 2020-07-01 11223/week @ 2020-07-08 12542/week @ 2020-07-15 12133/week @ 2020-07-22 13538/week @ 2020-07-29 13987/week @ 2020-08-05 14716/week @ 2020-08-12 12835/week @ 2020-08-19 12517/week @ 2020-08-26 11359/week @ 2020-09-02 14107/week @ 2020-09-09 13875/week @ 2020-09-16

30,307 downloads per month
Used in 246 crates (13 directly)

MIT license

44KB
967 lines

byte-slice-cast crates.io Build Status docs.rs

Safely cast between byte slices and slices of another built-in fundamental number type.

LICENSE

byte-slice-cast is licensed under the MIT license (LICENSE or http://opensource.org/licenses/MIT).

Contribution

Any kinds of contributions are welcome as a pull request.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in send-cell by you shall be licensed under the MIT license as above, without any additional terms or conditions.


lib.rs:

Safely cast bytes slices from/to slices of built-in fundamental numeric types.

The provided traits here allow safe casting between byte slices and slices of fundamental numeric types, like integers and floating point numbers. During casting, checks are performed to ensure that the output slice is safe to use: the input slice must be properly aligned for the output type and contain an integer number of values.

Instead of working only on slices, the traits work on AsRef<[T]> in the immutable case and on AsMut<[T]> for the mutable case. As such, it is possible to directly work on e.g. Vec<T> and Box<[T]> too.

The content of the output slice will be bitwise equivalent to the input slice, as such extra care has to be taken with regard to endianness.

Example with slices

# extern crate byte_slice_cast;
# fn main() {
use byte_slice_cast::*;

let slice = [0x0102u16, 0x0304u16, 0x0506u16];

let converted_slice = slice.as_byte_slice();

if cfg!(target_endian = "big") {
    assert_eq!(converted_slice, &[1, 2, 3, 4, 5, 6]);
} else {
    assert_eq!(converted_slice, &[2, 1, 4, 3, 6, 5]);
}

let converted_back_slice = converted_slice.as_slice_of::<u16>().unwrap();

assert_eq!(converted_back_slice, &slice);
# }

Example with mutable slices

# extern crate byte_slice_cast;
# fn main() {
use byte_slice_cast::*;

let mut slice = [0u32; 1];
let mut converted_slice = slice.as_mut_byte_slice();
converted_slice.copy_from_slice(&[0x12, 0x34, 0x56, 0x78]);

let mut converted_slice = converted_slice.as_mut_slice_of::<u16>().unwrap();
converted_slice[0] = 0xffff;

if cfg!(target_endian = "big") {
    assert_eq!(&slice, &[0xffff5678]);
} else {
    assert_eq!(&slice, &[0x7856ffff]);
}

# }

Example with Vec<T>

# extern crate byte_slice_cast;
# fn main() {
# #[cfg(feature = "alloc")] {
use byte_slice_cast::*;

let vec = vec![0x0102u16, 0x0304u16, 0x0506u16];
let converted_vec = vec.into_byte_vec();

if cfg!(target_endian = "big") {
    assert_eq!(converted_vec, &[1, 2, 3, 4, 5, 6]);
} else {
    assert_eq!(converted_vec, &[2, 1, 4, 3, 6, 5]);
}

let converted_back_vec = converted_vec.into_vec_of::<u16>().unwrap();
assert_eq!(&converted_back_vec[..], &[0x0102u16, 0x0304u16, 0x0506u16]);
# }
# }

No runtime deps

Features

  • alloc
  • std