fn cast_copy_into<T: ByteSafe + ?Sized>(&self, dest: &mut T)
    {
        <T>::bytesafe();
        <Self>::bytesafe();

        /* Validate source and dest are exactly the same size */
        let dest_sz = core::mem::size_of_val(dest);
        let src_sz  = core::mem::size_of_val(self);
        assert!(dest_sz == src_sz);

        unsafe {
            core::ptr::copy_nonoverlapping(
                self as *const _ as *const u8,
                dest as *mut _ as *mut u8,
                src_sz);
        }
    }
/// Copy the underlying bits from `Self` into `dest`
///
/// This is similar to cast_copy, however it copies into a mutable
/// reference. This makes it possible to copy into sized types such as
/// a slice of bytes.
///
/// This function will panic if `Self` is not the same size as `dest`
Copy the underlying bits from `Self` into `dest`
This is similar to cast_copy, however it copies into a mutable
reference. This makes it possible to copy into sized types such as
a slice of bytes.

This function will panic if `Self` is not the same size as `dest`
Copy the underlying bits from ` Self ` into ` dest ` This is similar to cast_copy however it copies into a mutable reference . This makes it possible to copy into sized types such as a slice of bytes . This function will panic if ` Self ` is not the same size as ` dest `
fn cast_copy_into<T: ByteSafe + ?Sized>(&self, dest: &mut T)
    {
        <T>::bytesafe();
        <Self>::bytesafe();
        /* Validate source and dest are exactly the same size */
        let dest_sz = core::mem::size_of_val(dest);
        let src_sz  = core::mem::size_of_val(self);
        assert!(dest_sz == src_sz);
        unsafe {
            core::ptr::copy_nonoverlapping(
                self as *const _ as *const u8,
                dest as *mut _ as *mut u8,
                src_sz);
        }
    }
fn cast_copy_into < T : ByteSafe + ? Sized > ( & self , dest : & mut T ) { < T > :: bytesafe ( ) ; < Self > :: bytesafe ( ) ; /* Validate source and dest are exactly the same size */ let dest_sz = core :: mem :: size_of_val ( dest ) ; let src_sz = core :: mem :: size_of_val ( self ) ; assert ! ( dest_sz src_sz ) ; unsafe { core :: ptr :: copy_nonoverlapping ( self as * const _ as * const u8 , dest as * mut _ as * mut u8 , src_sz ) ; } }
Copy the underlying bits from `Self` into `dest`
This is similar to cast_copy, however it copies into a mutable
reference.
Copy the underlying bits from ` Self ` into ` dest ` This is similar to cast_copy however it copies into a mutable reference .
&self
dest
&mut T
&self
dest
&mut T