Trait simple_parse::SpReadRaw

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

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

Parses Self from a Cursor<&[u8]>

Required methods

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

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

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

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

Converts bytes from a Cursor<&[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. This should not be done if Self itself contains non-primitive types, references, slices, etc…

Loading content...

Provided methods

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

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

Loading content...

Implementations on Foreign Types

impl<'b> SpReadRaw<'b> for u8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for u16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for u32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for u64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for u128

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for usize

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for i8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for i16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for i32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for i64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for i128

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for isize

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for bool

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

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

impl<'b> SpReadRaw<'b> for f32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for f64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicU8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicU16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicU32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicU64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicUsize

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicI8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicI16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicI32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicI64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicIsize

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for AtomicBool

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

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

impl<'b> SpReadRaw<'b> for NonZeroU8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroU16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroU32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroU64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroU128

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroUsize

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroI8

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroI16

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroI32

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroI64

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroI128

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for NonZeroIsize

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

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

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

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

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

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

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

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

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

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

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

impl<'b> SpReadRaw<'b> for String

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

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

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

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

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

impl<'b> SpReadRaw<'b> for CString

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

Loading content...