Trait simple_parse::SpReadRawMut

pub trait SpReadRawMut<'b> {
    fn inner_from_mut_slice(
        src: &mut Cursor<&'b mut [u8]>, 
        ctx: &mut SpCtx
    ) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints;
    unsafe fn inner_from_mut_slice_unchecked(
        checked_bytes: *mut u8, 
        src: &mut Cursor<&'b mut [u8]>, 
        ctx: &mut SpCtx
    ) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints;

    fn from_mut_slice(src: &mut Cursor<&'b mut [u8]>) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints,
    { ... }
}

Parses Self from a Cursor<&mut [u8]>

Required methods

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a Cursor<&mut [u8]> into Self

This functions allows specifying endianness and count fields as opposed to using defaults with from_slice

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a Cursor<&mut [u8]> into Self with some assumptions on checked_bytes

Safety

This function assumes that checked_bytes points to at least Self::STATIC_SIZE bytes.

If this is implemented on a dynamic type, the implementors MUST check if count is provided. If it is provided, Self::COUNT_SIZE less bytes can be trusted from checked_bytes.

This function also allows returning references into the Cursor<&[u8]> when Self is a reference &T or &mut T. This should not be done if Self itself contains non-primitive types, references, slices, etc…

Loading content...

Provided methods

fn from_mut_slice(src: &mut Cursor<&'b mut [u8]>) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a Cursor<&mut [u8]> into Self

Loading content...

Implementations on Foreign Types

impl<'b> SpReadRawMut<'b> for u8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &u8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut u8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[u8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [u8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for u16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &u16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut u16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[u16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [u16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for u32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &u32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut u32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[u32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [u32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for u64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &u64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut u64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[u64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [u64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for u128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &u128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut u128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[u128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [u128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for usize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &usize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut usize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[usize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [usize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for i8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &i8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut i8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[i8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [i8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for i16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &i16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut i16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[i16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [i16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for i32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &i32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut i32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[i32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [i32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for i64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &i64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut i64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[i64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [i64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for i128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &i128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut i128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[i128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [i128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for isize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &isize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut isize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[isize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [isize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for bool

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for f32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &f32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut f32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[f32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [f32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for f64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &f64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut f64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[f64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [f64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicU8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicU8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicU16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicU16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicU32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicU32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicU64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicU64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicUsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicUsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicI8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicI8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicI16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicI16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicI32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicI32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicI64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicI64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &AtomicIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut AtomicIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[AtomicIsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [AtomicIsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for AtomicBool

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroU8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroU8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroU8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroU16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroU16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroU16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroU32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroU32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroU32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroU64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroU64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroU64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroU128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroU128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroU128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroU128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroU128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroUsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroUsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroUsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroI8

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroI8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroI8]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroI16

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroI16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroI16]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroI32

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroI32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroI32]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroI64

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroI64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroI64]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroI128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroI128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroI128

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroI128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroI128]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for NonZeroIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &NonZeroIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut NonZeroIsize

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &[NonZeroIsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &mut [NonZeroIsize]

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &'b str

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for String

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for &'b CStr

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpReadRawMut<'b> for CString

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, T: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for Option<T>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, T: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for Vec<T>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, T: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for VecDeque<T>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, T: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for LinkedList<T>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, K: SpReadRawMut<'b> + SpOptHints + Eq + Hash> SpReadRawMut<'b> for HashSet<K>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, K: SpReadRawMut<'b> + SpOptHints + Ord> SpReadRawMut<'b> for BTreeSet<K>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, K: SpReadRawMut<'b> + SpOptHints + Eq + Hash, V: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for HashMap<K, V>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, K: SpReadRawMut<'b> + SpOptHints + Ord, V: SpReadRawMut<'b> + SpOptHints> SpReadRawMut<'b> for BTreeMap<K, V>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b, T: SpReadRawMut<'b> + SpOptHints + Ord> SpReadRawMut<'b> for BinaryHeap<T>

fn inner_from_mut_slice(
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_mut_slice_unchecked(
    checked_bytes: *mut u8,
    src: &mut Cursor<&'b mut [u8]>,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Loading content...

Implementors

Loading content...