Trait simple_parse::SpRead

pub trait SpRead {
    fn inner_from_reader<R: Read + ?Sized>(
        src: &mut R, 
        ctx: &mut SpCtx
    ) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints;
    unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
        checked_bytes: *mut u8, 
        src: &mut R, 
        ctx: &mut SpCtx
    ) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints;

    fn from_reader<R: Read + ?Sized>(src: &mut R) -> Result<Self, SpError>
    where
        Self: Sized + SpOptHints,
    { ... }
}

Parses Self from a source implementing Read (File,TcpStream, etc…)

This trait is most usefull when the bytes are coming from some kind of IO stream. When possible, it is recommend to use SpReadRaw instead for better performance.

Required methods

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a Reader into Self

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

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a &mut Read 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.

Loading content...

Provided methods

fn from_reader<R: Read + ?Sized>(src: &mut R) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Converts bytes from a &mut Read into Self

Loading content...

Implementations on Foreign Types

impl<'b> SpRead for u8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for u16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for u32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for u64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for u128

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for usize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for i8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for i16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for i32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for i64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for i128

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for isize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for bool

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for f32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for f64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicU8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicU16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicU32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicU64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicUsize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicI8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicI16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicI32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicI64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for AtomicIsize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroU8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroU16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroU32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroU64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroU128

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroUsize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroI8

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroI16

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroI32

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroI64

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroI128

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for NonZeroIsize

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for String

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

impl<'b> SpRead for CString

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

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

fn inner_from_reader<R: Read + ?Sized>(
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

unsafe fn inner_from_reader_unchecked<R: Read + ?Sized>(
    checked_bytes: *mut u8,
    src: &mut R,
    ctx: &mut SpCtx
) -> Result<Self, SpError> where
    Self: Sized + SpOptHints, 

Loading content...

Implementors

Loading content...