Struct ownedbytes::OwnedBytes

pub struct OwnedBytes { /* fields omitted */ }

An OwnedBytes simply wraps an object that owns a slice of data and exposes this data as a static slice.

The backing object is required to be StableDeref.

Implementations

impl OwnedBytes

pub fn empty() -> OwnedBytes

Creates an empty OwnedBytes.

pub fn new<T: StableDeref + Deref<Target = [u8]> + 'static + Send + Sync>(
    data_holder: T
) -> OwnedBytes

Creates an OwnedBytes intance given a StableDeref object.

pub fn slice(&self, range: Range<usize>) -> Self

creates a fileslice that is just a view over a slice of the data.

pub fn as_slice(&self) -> &[u8]

Returns the underlying slice of data. Deref and AsRef are also available.

pub fn len(&self) -> usize

Returns the len of the slice.

pub fn split(self, split_len: usize) -> (OwnedBytes, OwnedBytes)

Splits the OwnedBytes into two OwnedBytes (left, right).

Left will hold split_len bytes.

This operation is cheap and does not require to copy any memory. On the other hand, both left and right retain a handle over the entire slice of memory. In other words, the memory will only be released when both left and right are dropped.

pub fn split_off(&mut self, split_len: usize) -> OwnedBytes

Splits the right part of the OwnedBytes at the given offset.

self is truncated to split_len, left with the remaining bytes.

pub fn is_empty(&self) -> bool

Returns true iff this OwnedBytes is empty.

pub fn advance(&mut self, advance_len: usize)

Drops the left most advance_len bytes.

See also .clip(clip_len: usize)).

pub fn read_u8(&mut self) -> u8

Reads an u8 from the OwnedBytes and advance by one byte.

pub fn read_u64(&mut self) -> u64

Reads an u64 encoded as little-endian from the OwnedBytes and advance by 8 bytes.

Trait Implementations

impl AsRef<[u8]> for OwnedBytes

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl Clone for OwnedBytes

fn clone(&self) -> OwnedBytes

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OwnedBytes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for OwnedBytes

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: ?Sized> PartialEq<&'a T> for OwnedBytes where
    OwnedBytes: PartialEq<T>, 

fn eq(&self, other: &&'a T) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<[u8]> for OwnedBytes

fn eq(&self, other: &[u8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<OwnedBytes> for OwnedBytes

fn eq(&self, other: &OwnedBytes) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<str> for OwnedBytes

fn eq(&self, other: &str) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Read for OwnedBytes

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

Read all bytes until EOF in this source, placing them into buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

Read the exact number of bytes required to fill buf.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

unsafe fn initializer(&self) -> Initializer

🔬 This is a nightly-only experimental API. (read_initializer)

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.

impl Eq for OwnedBytes