Deleted vendor folder

1 files changed, 0 insertions, 522 deletions

diff --git a/vendor/bytemuck/src/checked.rs b/vendor/bytemuck/src/checked.rs
deleted file mode 100644
index 722c31d..0000000
--- a/vendor/bytemuck/src/checked.rs
+++ /dev/null
@@ -1,522 +0,0 @@
-//! Checked versions of the casting functions exposed in crate root
-//! that support [`CheckedBitPattern`] types.
-
-use crate::{
-  internal::{self, something_went_wrong},
-  AnyBitPattern, NoUninit,
-};
-
-/// A marker trait that allows types that have some invalid bit patterns to be
-/// used in places that otherwise require [`AnyBitPattern`] or [`Pod`] types by
-/// performing a runtime check on a perticular set of bits. This is particularly
-/// useful for types like fieldless ('C-style') enums, [`char`], bool, and
-/// structs containing them.
-///
-/// To do this, we define a `Bits` type which is a type with equivalent layout
-/// to `Self` other than the invalid bit patterns which disallow `Self` from
-/// being [`AnyBitPattern`]. This `Bits` type must itself implement
-/// [`AnyBitPattern`]. Then, we implement a function that checks whether a
-/// certain instance of the `Bits` is also a valid bit pattern of `Self`. If
-/// this check passes, then we can allow casting from the `Bits` to `Self` (and
-/// therefore, any type which is able to be cast to `Bits` is also able to be
-/// cast to `Self`).
-///
-/// [`AnyBitPattern`] is a subset of [`CheckedBitPattern`], meaning that any `T:
-/// AnyBitPattern` is also [`CheckedBitPattern`]. This means you can also use
-/// any [`AnyBitPattern`] type in the checked versions of casting functions in
-/// this module. If it's possible, prefer implementing [`AnyBitPattern`] for
-/// your type directly instead of [`CheckedBitPattern`] as it gives greater
-/// flexibility.
-///
-/// # Derive
-///
-/// A `#[derive(CheckedBitPattern)]` macro is provided under the `derive`
-/// feature flag which will automatically validate the requirements of this
-/// trait and implement the trait for you for both enums and structs. This is
-/// the recommended method for implementing the trait, however it's also
-/// possible to do manually.
-///
-/// # Example
-///
-/// If manually implementing the trait, we can do something like so:
-///
-/// ```rust
-/// use bytemuck::{CheckedBitPattern, NoUninit};
-///
-/// #[repr(u32)]
-/// #[derive(Copy, Clone)]
-/// enum MyEnum {
-///     Variant0 = 0,
-///     Variant1 = 1,
-///     Variant2 = 2,
-/// }
-///
-/// unsafe impl CheckedBitPattern for MyEnum {
-///     type Bits = u32;
-///
-///     fn is_valid_bit_pattern(bits: &u32) -> bool {
-///         match *bits {
-///             0 | 1 | 2 => true,
-///             _ => false,
-///         }
-///     }
-/// }
-///
-/// // It is often useful to also implement `NoUninit` on our `CheckedBitPattern` types.
-/// // This will allow us to do casting of mutable references (and mutable slices).
-/// // It is not always possible to do so, but in this case we have no padding so it is.
-/// unsafe impl NoUninit for MyEnum {}
-/// ```
-///
-/// We can now use relevant casting functions. For example,
-///
-/// ```rust
-/// # use bytemuck::{CheckedBitPattern, NoUninit};
-/// # #[repr(u32)]
-/// # #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-/// # enum MyEnum {
-/// #     Variant0 = 0,
-/// #     Variant1 = 1,
-/// #     Variant2 = 2,
-/// # }
-/// # unsafe impl NoUninit for MyEnum {}
-/// # unsafe impl CheckedBitPattern for MyEnum {
-/// #     type Bits = u32;
-/// #     fn is_valid_bit_pattern(bits: &u32) -> bool {
-/// #         match *bits {
-/// #             0 | 1 | 2 => true,
-/// #             _ => false,
-/// #         }
-/// #     }
-/// # }
-/// use bytemuck::{bytes_of, bytes_of_mut};
-/// use bytemuck::checked;
-///
-/// let bytes = bytes_of(&2u32);
-/// let result = checked::try_from_bytes::<MyEnum>(bytes);
-/// assert_eq!(result, Ok(&MyEnum::Variant2));
-///
-/// // Fails for invalid discriminant
-/// let bytes = bytes_of(&100u32);
-/// let result = checked::try_from_bytes::<MyEnum>(bytes);
-/// assert!(result.is_err());
-///
-/// // Since we implemented NoUninit, we can also cast mutably from an original type
-/// // that is `NoUninit + AnyBitPattern`:
-/// let mut my_u32 = 2u32;
-/// {
-///   let as_enum_mut = checked::cast_mut::<_, MyEnum>(&mut my_u32);
-///   assert_eq!(as_enum_mut, &mut MyEnum::Variant2);
-///   *as_enum_mut = MyEnum::Variant0;
-/// }
-/// assert_eq!(my_u32, 0u32);
-/// ```
-///
-/// # Safety
-///
-/// * `Self` *must* have the same layout as the specified `Bits` except for
-/// the possible invalid bit patterns being checked during
-/// [`is_valid_bit_pattern`].
-///   * This almost certainly means your type must be `#[repr(C)]` or a similar
-///   specified repr, but if you think you know better, you probably don't. If
-/// you   still think you know better, be careful and have fun. And don't mess
-/// it up   (I mean it).
-/// * If [`is_valid_bit_pattern`] returns true, then the bit pattern contained
-///   in `bits` must also be valid for an instance of `Self`.
-/// * Probably more, don't mess it up (I mean it 2.0)
-///
-/// [`is_valid_bit_pattern`]: CheckedBitPattern::is_valid_bit_pattern
-/// [`Pod`]: crate::Pod
-pub unsafe trait CheckedBitPattern: Copy {
-  /// `Self` *must* have the same layout as the specified `Bits` except for
-  /// the possible invalid bit patterns being checked during
-  /// [`is_valid_bit_pattern`].
-  ///
-  /// [`is_valid_bit_pattern`]: CheckedBitPattern::is_valid_bit_pattern
-  type Bits: AnyBitPattern;
-
-  /// If this function returns true, then it must be valid to reinterpret `bits`
-  /// as `&Self`.
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool;
-}
-
-unsafe impl<T: AnyBitPattern> CheckedBitPattern for T {
-  type Bits = T;
-
-  #[inline(always)]
-  fn is_valid_bit_pattern(_bits: &T) -> bool {
-    true
-  }
-}
-
-unsafe impl CheckedBitPattern for char {
-  type Bits = u32;
-
-  #[inline]
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-    core::char::from_u32(*bits).is_some()
-  }
-}
-
-unsafe impl CheckedBitPattern for bool {
-  type Bits = u8;
-
-  #[inline]
-  fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-    match *bits {
-      0 | 1 => true,
-      _ => false,
-    }
-  }
-}
-
-// Rust 1.70.0 documents that NonZero[int] has the same layout as [int].
-macro_rules! impl_checked_for_nonzero {
-  ($($nonzero:ty: $primitive:ty),* $(,)?) => {
-    $(
-      unsafe impl CheckedBitPattern for $nonzero {
-        type Bits = $primitive;
-
-        #[inline]
-        fn is_valid_bit_pattern(bits: &Self::Bits) -> bool {
-          *bits != 0
-        }
-      }
-    )*
-  };
-}
-impl_checked_for_nonzero! {
-  core::num::NonZeroU8: u8,
-  core::num::NonZeroI8: i8,
-  core::num::NonZeroU16: u16,
-  core::num::NonZeroI16: i16,
-  core::num::NonZeroU32: u32,
-  core::num::NonZeroI32: i32,
-  core::num::NonZeroU64: u64,
-  core::num::NonZeroI64: i64,
-  core::num::NonZeroI128: i128,
-  core::num::NonZeroU128: u128,
-  core::num::NonZeroUsize: usize,
-  core::num::NonZeroIsize: isize,
-}
-
-/// The things that can go wrong when casting between [`CheckedBitPattern`] data
-/// forms.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum CheckedCastError {
-  /// An error occurred during a true-[`Pod`] cast
-  ///
-  /// [`Pod`]: crate::Pod
-  PodCastError(crate::PodCastError),
-  /// When casting to a [`CheckedBitPattern`] type, it is possible that the
-  /// original data contains an invalid bit pattern. If so, the cast will
-  /// fail and this error will be returned. Will never happen on casts
-  /// between [`Pod`] types.
-  ///
-  /// [`Pod`]: crate::Pod
-  InvalidBitPattern,
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl core::fmt::Display for CheckedCastError {
-  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 CheckedCastError {}
-
-impl From<crate::PodCastError> for CheckedCastError {
-  fn from(err: crate::PodCastError) -> CheckedCastError {
-    CheckedCastError::PodCastError(err)
-  }
-}
-
-/// 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
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_from_bytes<T: CheckedBitPattern>(
-  s: &[u8],
-) -> Result<&T, CheckedCastError> {
-  let pod = crate::try_from_bytes(s)?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &*(pod as *const <T as CheckedBitPattern>::Bits as *const T) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_from_bytes_mut<T: CheckedBitPattern + NoUninit>(
-  s: &mut [u8],
-) -> Result<&mut T, CheckedCastError> {
-  let pod = unsafe { internal::try_from_bytes_mut(s) }?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &mut *(pod as *mut <T as CheckedBitPattern>::Bits as *mut T) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Reads from the bytes as if they were a `T`.
-///
-/// ## Failure
-/// * If the `bytes` length is not equal to `size_of::<T>()`.
-/// * If the slice contains an invalid bit pattern for `T`
-#[inline]
-pub fn try_pod_read_unaligned<T: CheckedBitPattern>(
-  bytes: &[u8],
-) -> Result<T, CheckedCastError> {
-  let pod = crate::try_pod_read_unaligned(bytes)?;
-
-  if <T as CheckedBitPattern>::is_valid_bit_pattern(&pod) {
-    Ok(unsafe { transmute!(pod) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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.
-/// * If `a` contains an invalid bit pattern for `B` this fails.
-#[inline]
-pub fn try_cast<A: NoUninit, B: CheckedBitPattern>(
-  a: A,
-) -> Result<B, CheckedCastError> {
-  let pod = crate::try_cast(a)?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(&pod) {
-    Ok(unsafe { transmute!(pod) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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.
-/// * If `a` contains an invalid bit pattern for `B` this fails.
-#[inline]
-pub fn try_cast_ref<A: NoUninit, B: CheckedBitPattern>(
-  a: &A,
-) -> Result<&B, CheckedCastError> {
-  let pod = crate::try_cast_ref(a)?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &*(pod as *const <B as CheckedBitPattern>::Bits as *const B) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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: CheckedBitPattern + NoUninit,
->(
-  a: &mut A,
-) -> Result<&mut B, CheckedCastError> {
-  let pod = unsafe { internal::try_cast_mut(a) }?;
-
-  if <B as CheckedBitPattern>::is_valid_bit_pattern(pod) {
-    Ok(unsafe { &mut *(pod as *mut <B as CheckedBitPattern>::Bits as *mut B) })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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::<A>() == output.len() * size_of::<B>()`
-///
-/// ## 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.
-/// * If any element of the converted slice would contain an invalid bit pattern
-///   for `B` this fails.
-#[inline]
-pub fn try_cast_slice<A: NoUninit, B: CheckedBitPattern>(
-  a: &[A],
-) -> Result<&[B], CheckedCastError> {
-  let pod = crate::try_cast_slice(a)?;
-
-  if pod.iter().all(|pod| <B as CheckedBitPattern>::is_valid_bit_pattern(pod)) {
-    Ok(unsafe {
-      core::slice::from_raw_parts(pod.as_ptr() as *const B, pod.len())
-    })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// 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: CheckedBitPattern + NoUninit,
->(
-  a: &mut [A],
-) -> Result<&mut [B], CheckedCastError> {
-  let pod = unsafe { internal::try_cast_slice_mut(a) }?;
-
-  if pod.iter().all(|pod| <B as CheckedBitPattern>::is_valid_bit_pattern(pod)) {
-    Ok(unsafe {
-      core::slice::from_raw_parts_mut(pod.as_mut_ptr() as *mut B, pod.len())
-    })
-  } else {
-    Err(CheckedCastError::InvalidBitPattern)
-  }
-}
-
-/// Re-interprets `&[u8]` as `&T`.
-///
-/// ## Panics
-///
-/// This is [`try_from_bytes`] but will panic on error.
-#[inline]
-pub fn from_bytes<T: CheckedBitPattern>(s: &[u8]) -> &T {
-  match try_from_bytes(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes", e),
-  }
-}
-
-/// 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<T: NoUninit + CheckedBitPattern>(s: &mut [u8]) -> &mut T {
-  match try_from_bytes_mut(s) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("from_bytes_mut", e),
-  }
-}
-
-/// 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<T: CheckedBitPattern>(bytes: &[u8]) -> T {
-  match try_pod_read_unaligned(bytes) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("pod_read_unaligned", e),
-  }
-}
-
-/// Cast `T` into `U`
-///
-/// ## Panics
-///
-/// * This is like [`try_cast`](try_cast), but will panic on a size mismatch.
-#[inline]
-pub fn cast<A: NoUninit, B: CheckedBitPattern>(a: A) -> B {
-  match try_cast(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast", e),
-  }
-}
-
-/// Cast `&mut T` into `&mut U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_mut`] but will panic on error.
-#[inline]
-pub fn cast_mut<
-  A: NoUninit + AnyBitPattern,
-  B: NoUninit + CheckedBitPattern,
->(
-  a: &mut A,
-) -> &mut B {
-  match try_cast_mut(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_mut", e),
-  }
-}
-
-/// Cast `&T` into `&U`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_ref`] but will panic on error.
-#[inline]
-pub fn cast_ref<A: NoUninit, B: CheckedBitPattern>(a: &A) -> &B {
-  match try_cast_ref(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_ref", e),
-  }
-}
-
-/// Cast `&[A]` into `&[B]`.
-///
-/// ## Panics
-///
-/// This is [`try_cast_slice`] but will panic on error.
-#[inline]
-pub fn cast_slice<A: NoUninit, B: CheckedBitPattern>(a: &[A]) -> &[B] {
-  match try_cast_slice(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_slice", e),
-  }
-}
-
-/// 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 + CheckedBitPattern,
->(
-  a: &mut [A],
-) -> &mut [B] {
-  match try_cast_slice_mut(a) {
-    Ok(t) => t,
-    Err(e) => something_went_wrong("cast_slice_mut", e),
-  }
-}