From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/bytemuck/src/lib.rs | 457 --------------------------------------------- 1 file changed, 457 deletions(-) delete mode 100644 vendor/bytemuck/src/lib.rs (limited to 'vendor/bytemuck/src/lib.rs') diff --git a/vendor/bytemuck/src/lib.rs b/vendor/bytemuck/src/lib.rs deleted file mode 100644 index 000dacb..0000000 --- a/vendor/bytemuck/src/lib.rs +++ /dev/null @@ -1,457 +0,0 @@ -#![no_std] -#![warn(missing_docs)] -#![allow(clippy::match_like_matches_macro)] -#![allow(clippy::uninlined_format_args)] -#![cfg_attr(feature = "nightly_docs", feature(doc_cfg))] -#![cfg_attr(feature = "nightly_portable_simd", feature(portable_simd))] -#![cfg_attr(feature = "nightly_stdsimd", feature(stdsimd))] - -//! This crate gives small utilities for casting between plain data types. -//! -//! ## Basics -//! -//! Data comes in five basic forms in Rust, so we have five basic casting -//! functions: -//! -//! * `T` uses [`cast`] -//! * `&T` uses [`cast_ref`] -//! * `&mut T` uses [`cast_mut`] -//! * `&[T]` uses [`cast_slice`] -//! * `&mut [T]` uses [`cast_slice_mut`] -//! -//! Some casts will never fail (eg: `cast::` always works), other -//! casts might fail (eg: `cast_ref::<[u8; 4], u32>` will fail if the reference -//! isn't already aligned to 4). Each casting function has a "try" version which -//! will return a `Result`, and the "normal" version which will simply panic on -//! invalid input. -//! -//! ## Using Your Own Types -//! -//! All the functions here are guarded by the [`Pod`] trait, which is a -//! sub-trait of the [`Zeroable`] trait. -//! -//! If you're very sure that your type is eligible, you can implement those -//! traits for your type and then they'll have full casting support. However, -//! these traits are `unsafe`, and you should carefully read the requirements -//! before adding the them to your own types. -//! -//! ## Features -//! -//! * This crate is core only by default, but if you're using Rust 1.36 or later -//! you can enable the `extern_crate_alloc` cargo feature for some additional -//! methods related to `Box` and `Vec`. Note that the `docs.rs` documentation -//! is always built with `extern_crate_alloc` cargo feature enabled. - -#[cfg(all(target_arch = "aarch64", feature = "aarch64_simd"))] -use core::arch::aarch64; -#[cfg(all(target_arch = "wasm32", feature = "wasm_simd"))] -use core::arch::wasm32; -#[cfg(target_arch = "x86")] -use core::arch::x86; -#[cfg(target_arch = "x86_64")] -use core::arch::x86_64; -// -use core::{marker::*, mem::*, num::*, ptr::*}; - -// Used from macros to ensure we aren't using some locally defined name and -// actually are referencing libcore. This also would allow pre-2018 edition -// crates to use our macros, but I'm not sure how important that is. -#[doc(hidden)] -pub use ::core as __core; - -#[cfg(not(feature = "min_const_generics"))] -macro_rules! impl_unsafe_marker_for_array { - ( $marker:ident , $( $n:expr ),* ) => { - $(unsafe impl $marker for [T; $n] where T: $marker {})* - } -} - -/// A macro to transmute between two types without requiring knowing size -/// statically. -macro_rules! transmute { - ($val:expr) => { - ::core::mem::transmute_copy(&::core::mem::ManuallyDrop::new($val)) - }; -} - -/// A macro to implement marker traits for various simd types. -/// #[allow(unused)] because the impls are only compiled on relevant platforms -/// with relevant cargo features enabled. -#[allow(unused)] -macro_rules! impl_unsafe_marker_for_simd { - ($(#[cfg($cfg_predicate:meta)])? unsafe impl $trait:ident for $platform:ident :: {}) => {}; - ($(#[cfg($cfg_predicate:meta)])? unsafe impl $trait:ident for $platform:ident :: { $first_type:ident $(, $types:ident)* $(,)? }) => { - $( #[cfg($cfg_predicate)] )? - $( #[cfg_attr(feature = "nightly_docs", doc(cfg($cfg_predicate)))] )? - unsafe impl $trait for $platform::$first_type {} - $( #[cfg($cfg_predicate)] )? // To prevent recursion errors if nothing is going to be expanded anyway. - impl_unsafe_marker_for_simd!($( #[cfg($cfg_predicate)] )? unsafe impl $trait for $platform::{ $( $types ),* }); - }; -} - -#[cfg(feature = "extern_crate_std")] -extern crate std; - -#[cfg(feature = "extern_crate_alloc")] -extern crate alloc; -#[cfg(feature = "extern_crate_alloc")] -#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_alloc")))] -pub mod allocation; -#[cfg(feature = "extern_crate_alloc")] -pub use allocation::*; - -mod anybitpattern; -pub use anybitpattern::*; - -pub mod checked; -pub use checked::CheckedBitPattern; - -mod internal; - -mod zeroable; -pub use zeroable::*; -mod zeroable_in_option; -pub use zeroable_in_option::*; - -mod pod; -pub use pod::*; -mod pod_in_option; -pub use pod_in_option::*; - -#[cfg(feature = "must_cast")] -mod must; -#[cfg(feature = "must_cast")] -#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "must_cast")))] -pub use must::*; - -mod no_uninit; -pub use no_uninit::*; - -mod contiguous; -pub use contiguous::*; - -mod offset_of; -pub use offset_of::*; - -mod transparent; -pub use transparent::*; - -#[cfg(feature = "derive")] -#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "derive")))] -pub use bytemuck_derive::{ - AnyBitPattern, ByteEq, ByteHash, CheckedBitPattern, Contiguous, NoUninit, - Pod, TransparentWrapper, Zeroable, -}; - -/// The things that can go wrong when casting between [`Pod`] data forms. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum PodCastError { - /// You tried to cast a slice to an element type with a higher alignment - /// requirement but the slice wasn't aligned. - TargetAlignmentGreaterAndInputNotAligned, - /// If the element size changes then the output slice changes length - /// accordingly. If the output slice wouldn't be a whole number of elements - /// then the conversion fails. - OutputSliceWouldHaveSlop, - /// When casting a slice you can't convert between ZST elements and non-ZST - /// elements. When casting an individual `T`, `&T`, or `&mut T` value the - /// source size and destination size must be an exact match. - SizeMismatch, - /// For this type of cast the alignments must be exactly the same and they - /// were not so now you're sad. - /// - /// This error is generated **only** by operations that cast allocated types - /// (such as `Box` and `Vec`), because in that case the alignment must stay - /// exact. - AlignmentMismatch, -} -#[cfg(not(target_arch = "spirv"))] -impl core::fmt::Display for PodCastError { - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { - write!(f, "{:?}", self) - } -} -#[cfg(feature = "extern_crate_std")] -#[cfg_attr(feature = "nightly_docs", doc(cfg(feature = "extern_crate_std")))] -impl std::error::Error for PodCastError {} - -/// Re-interprets `&T` as `&[u8]`. -/// -/// Any ZST becomes an empty slice, and in that case the pointer value of that -/// empty slice might not match the pointer value of the input reference. -#[inline] -pub fn bytes_of(t: &T) -> &[u8] { - unsafe { internal::bytes_of(t) } -} - -/// Re-interprets `&mut T` as `&mut [u8]`. -/// -/// Any ZST becomes an empty slice, and in that case the pointer value of that -/// empty slice might not match the pointer value of the input reference. -#[inline] -pub fn bytes_of_mut(t: &mut T) -> &mut [u8] { - unsafe { internal::bytes_of_mut(t) } -} - -/// Re-interprets `&[u8]` as `&T`. -/// -/// ## Panics -/// -/// This is [`try_from_bytes`] but will panic on error. -#[inline] -pub fn from_bytes(s: &[u8]) -> &T { - unsafe { internal::from_bytes(s) } -} - -/// Re-interprets `&mut [u8]` as `&mut T`. -/// -/// ## Panics -/// -/// This is [`try_from_bytes_mut`] but will panic on error. -#[inline] -pub fn from_bytes_mut(s: &mut [u8]) -> &mut T { - unsafe { internal::from_bytes_mut(s) } -} - -/// Reads from the bytes as if they were a `T`. -/// -/// ## Failure -/// * If the `bytes` length is not equal to `size_of::()`. -#[inline] -pub fn try_pod_read_unaligned( - bytes: &[u8], -) -> Result { - unsafe { internal::try_pod_read_unaligned(bytes) } -} - -/// Reads the slice into a `T` value. -/// -/// ## Panics -/// * This is like `try_pod_read_unaligned` but will panic on failure. -#[inline] -pub fn pod_read_unaligned(bytes: &[u8]) -> T { - unsafe { internal::pod_read_unaligned(bytes) } -} - -/// Re-interprets `&[u8]` as `&T`. -/// -/// ## Failure -/// -/// * If the slice isn't aligned for the new type -/// * If the slice's length isn’t exactly the size of the new type -#[inline] -pub fn try_from_bytes(s: &[u8]) -> Result<&T, PodCastError> { - unsafe { internal::try_from_bytes(s) } -} - -/// Re-interprets `&mut [u8]` as `&mut T`. -/// -/// ## Failure -/// -/// * If the slice isn't aligned for the new type -/// * If the slice's length isn’t exactly the size of the new type -#[inline] -pub fn try_from_bytes_mut( - s: &mut [u8], -) -> Result<&mut T, PodCastError> { - unsafe { internal::try_from_bytes_mut(s) } -} - -/// Cast `T` into `U` -/// -/// ## Panics -/// -/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch. -#[inline] -pub fn cast(a: A) -> B { - unsafe { internal::cast(a) } -} - -/// Cast `&mut T` into `&mut U`. -/// -/// ## Panics -/// -/// This is [`try_cast_mut`] but will panic on error. -#[inline] -pub fn cast_mut( - a: &mut A, -) -> &mut B { - unsafe { internal::cast_mut(a) } -} - -/// Cast `&T` into `&U`. -/// -/// ## Panics -/// -/// This is [`try_cast_ref`] but will panic on error. -#[inline] -pub fn cast_ref(a: &A) -> &B { - unsafe { internal::cast_ref(a) } -} - -/// Cast `&[A]` into `&[B]`. -/// -/// ## Panics -/// -/// This is [`try_cast_slice`] but will panic on error. -#[inline] -pub fn cast_slice(a: &[A]) -> &[B] { - unsafe { internal::cast_slice(a) } -} - -/// Cast `&mut [T]` into `&mut [U]`. -/// -/// ## Panics -/// -/// This is [`try_cast_slice_mut`] but will panic on error. -#[inline] -pub fn cast_slice_mut< - A: NoUninit + AnyBitPattern, - B: NoUninit + AnyBitPattern, ->( - a: &mut [A], -) -> &mut [B] { - unsafe { internal::cast_slice_mut(a) } -} - -/// As `align_to`, but safe because of the [`Pod`] bound. -#[inline] -pub fn pod_align_to( - vals: &[T], -) -> (&[T], &[U], &[T]) { - unsafe { vals.align_to::() } -} - -/// As `align_to_mut`, but safe because of the [`Pod`] bound. -#[inline] -pub fn pod_align_to_mut< - T: NoUninit + AnyBitPattern, - U: NoUninit + AnyBitPattern, ->( - vals: &mut [T], -) -> (&mut [T], &mut [U], &mut [T]) { - unsafe { vals.align_to_mut::() } -} - -/// Try to cast `T` into `U`. -/// -/// Note that for this particular type of cast, alignment isn't a factor. The -/// input value is semantically copied into the function and then returned to a -/// new memory location which will have whatever the required alignment of the -/// output type is. -/// -/// ## Failure -/// -/// * If the types don't have the same size this fails. -#[inline] -pub fn try_cast( - a: A, -) -> Result { - unsafe { internal::try_cast(a) } -} - -/// Try to convert a `&T` into `&U`. -/// -/// ## Failure -/// -/// * If the reference isn't aligned in the new type -/// * If the source type and target type aren't the same size. -#[inline] -pub fn try_cast_ref( - a: &A, -) -> Result<&B, PodCastError> { - unsafe { internal::try_cast_ref(a) } -} - -/// Try to convert a `&mut T` into `&mut U`. -/// -/// As [`try_cast_ref`], but `mut`. -#[inline] -pub fn try_cast_mut< - A: NoUninit + AnyBitPattern, - B: NoUninit + AnyBitPattern, ->( - a: &mut A, -) -> Result<&mut B, PodCastError> { - unsafe { internal::try_cast_mut(a) } -} - -/// Try to convert `&[A]` into `&[B]` (possibly with a change in length). -/// -/// * `input.as_ptr() as usize == output.as_ptr() as usize` -/// * `input.len() * size_of::() == output.len() * size_of::()` -/// -/// ## Failure -/// -/// * If the target type has a greater alignment requirement and the input slice -/// isn't aligned. -/// * If the target element type is a different size from the current element -/// type, and the output slice wouldn't be a whole number of elements when -/// accounting for the size change (eg: 3 `u16` values is 1.5 `u32` values, so -/// that's a failure). -/// * Similarly, you can't convert between a [ZST](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) -/// and a non-ZST. -#[inline] -pub fn try_cast_slice( - a: &[A], -) -> Result<&[B], PodCastError> { - unsafe { internal::try_cast_slice(a) } -} - -/// Try to convert `&mut [A]` into `&mut [B]` (possibly with a change in -/// length). -/// -/// As [`try_cast_slice`], but `&mut`. -#[inline] -pub fn try_cast_slice_mut< - A: NoUninit + AnyBitPattern, - B: NoUninit + AnyBitPattern, ->( - a: &mut [A], -) -> Result<&mut [B], PodCastError> { - unsafe { internal::try_cast_slice_mut(a) } -} - -/// Fill all bytes of `target` with zeroes (see [`Zeroable`]). -/// -/// This is similar to `*target = Zeroable::zeroed()`, but guarantees that any -/// padding bytes in `target` are zeroed as well. -/// -/// See also [`fill_zeroes`], if you have a slice rather than a single value. -#[inline] -pub fn write_zeroes(target: &mut T) { - struct EnsureZeroWrite(*mut T); - impl Drop for EnsureZeroWrite { - #[inline(always)] - fn drop(&mut self) { - unsafe { - core::ptr::write_bytes(self.0, 0u8, 1); - } - } - } - unsafe { - let guard = EnsureZeroWrite(target); - core::ptr::drop_in_place(guard.0); - drop(guard); - } -} - -/// Fill all bytes of `slice` with zeroes (see [`Zeroable`]). -/// -/// This is similar to `slice.fill(Zeroable::zeroed())`, but guarantees that any -/// padding bytes in `slice` are zeroed as well. -/// -/// See also [`write_zeroes`], which zeroes all bytes of a single value rather -/// than a slice. -#[inline] -pub fn fill_zeroes(slice: &mut [T]) { - if core::mem::needs_drop::() { - // If `T` needs to be dropped then we have to do this one item at a time, in - // case one of the intermediate drops does a panic. - slice.iter_mut().for_each(write_zeroes); - } else { - // Otherwise we can be really fast and just fill everthing with zeros. - let len = core::mem::size_of_val::<[T]>(slice); - unsafe { core::ptr::write_bytes(slice.as_mut_ptr() as *mut u8, 0u8, len) } - } -} -- cgit v1.2.3