Struct Pair

pub struct Pair<Part> { /* private fields */ }

Implementations

impl<'a> Pair<&'a [MaybeUninit<u8>]>

pub unsafe fn assume_init_io_slice(self) -> Pair<IoSlice<'a>>

Safety

Callers should guarantee the memory in the pair is initialized

impl<'a> Pair<&'a mut [MaybeUninit<u8>]>

pub unsafe fn assume_init_io_slice_mut(self) -> Pair<IoSliceMut<'a>>

Safety

Callers should guarantee the memory in the pair is initialized

impl<Part> Pair<Part>

where Part: Storage,

pub fn reader_slice(&mut self) -> &[Part]

pub fn reader_slice_mut(&mut self) -> &mut [Part]

impl<Part> Pair<Part>

where Part: Storage,

pub fn writer_slice(&mut self) -> &[Part]

pub fn writer_slice_mut(&mut self) -> &mut [Part]

impl<T> Pair<T>

pub fn map<F, U>(self, f: F) -> Pair<U>

where F: FnMut(T) -> U,

impl<Part, T> Pair<Part>

where Part: Deref<Target = [T]>,

pub fn get(&self, index: usize) -> Option<&T>

pub fn iter<'a>(&'a self) -> impl Iterator<Item = &'a T>

where T: 'a,

impl<Part, T> Pair<Part>

where Part: DerefMut<Target = [T]>,

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

pub fn iter_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut T> + 'a

where T: 'a,

impl<'a, T> Pair<&'a [MaybeUninit<T>]>

pub unsafe fn assume_init_ref(self) -> Pair<&'a [T]>

Safety

Callers should guarantee the memory in the pair is initialized

impl<'a, T> Pair<&'a mut [MaybeUninit<T>]>

pub unsafe fn assume_init_mut(self) -> Pair<&'a mut [T]>

Safety

Callers should guarantee the memory in the pair is initialized

Trait Implementations

impl<Part> From<(Part, Part)> for Pair<Part>

fn from((head, tail): (Part, Part)) -> Self

Converts to this type from the input type.

impl<Part> From<Pair<Part>> for (Part, Part)

fn from(pair: Pair<Part>) -> (Part, Part)

Converts to this type from the input type.

impl<S: Storage> Storage for Pair<S>

type Error = <S as Storage>::Error

fn buffered_len(&self) -> usize

Returns the length of the chunk

fn read_chunk(&mut self, watermark: usize) -> Result<Chunk<'_>, Self::Error>

Reads the current contiguous chunk

fn partial_copy_into<Dest>( &mut self, dest: &mut Dest, ) -> Result<Chunk<'_>, Self::Error>

where Dest: Storage + ?Sized,

Copies the reader into dest, with a trailing chunk of bytes.

fn copy_into<Dest>(&mut self, dest: &mut Dest) -> Result<(), Self::Error>

where Dest: Storage + ?Sized,

Copies the reader into dest.

fn buffer_is_empty(&self) -> bool

Returns if the chunk is empty

fn full_copy(&mut self) -> FullCopy<'_, Self>

Forces the entire reader to be copied, even when calling partial_copy_into.

fn track_read(&mut self) -> Tracked<'_, Self>

Tracks the number of bytes read from the storage

impl<S: Storage> Storage for Pair<S>

fn put_slice(&mut self, bytes: &[u8])

Writes a slice of bytes into the storage

fn put_uninit_slice<F, Error>( &mut self, payload_len: usize, f: F, ) -> Result<bool, Error>

where F: FnOnce(&mut UninitSlice) -> Result<(), Error>,

Tries to write into a uninit slice for the current storage

fn remaining_capacity(&self) -> usize

Returns the additional number of bytes that can be written to the storage

const SPECIALIZES_BYTES: bool = false

const SPECIALIZES_BYTES_MUT: bool = false

fn has_remaining_capacity(&self) -> bool

Returns true if the storage will accept any additional bytes

fn put_bytes(&mut self, bytes: Bytes)

Writes Bytes into the storage

fn put_bytes_mut(&mut self, bytes: BytesMut)

Writes BytesMut into the storage

fn put_chunk(&mut self, chunk: Chunk<'_>)

Writes a reader Chunk into the storage

fn with_write_limit(&mut self, max_len: usize) -> Limit<'_, Self>

Limits the number of bytes that can be written to the storage

fn track_write(&mut self) -> Tracked<'_, Self>

Tracks the number of bytes written to the storage

fn write_once(&mut self) -> WriteOnce<'_, Self>

Only allows a single write into the storage. After that, no more writes are allowed.