Struct mz_ore::bytes::SegmentedBytes

pub struct SegmentedBytes<const N: usize = 1> {
    segments: SmallVec<[(MaybeLgBytes, usize); N]>,
    len: usize,
}

Available on crate feature bytes_ only.

A cheaply clonable collection of possibly non-contiguous bytes.

Vec<u8> or Bytes are contiguous chunks of memory, which are fast (e.g. better cache locality) and easier to work with (e.g. can take a slice), but can cause problems (e.g. memory fragmentation) if you try to allocate a single very large chunk. Depending on the application, you probably don’t need a contiguous chunk of memory, just a way to store and iterate over a collection of bytes.

Note: SegmentedBytes is generic over a const N: usize. Internally we use a smallvec::SmallVec to store our Bytes segments, and N is how many Bytes we’ll store inline before spilling to the heap. We default N = 1, so in the case of a single Bytes segment, we avoid one layer of indirection.

Fields

segments: SmallVec<[(MaybeLgBytes, usize); N]>

Collection of non-contiguous segments, each segment is guaranteed to be non-empty.

len: usize

Pre-computed length of all the segments.

Implementations

impl SegmentedBytes

pub fn new<const N: usize>() -> SegmentedBytes<N>

Creates a new empty SegmentedBytes, reserving space inline for N segments.

Note: If you don’t know how many segments you have, you should use SegmentedBytes::default.

impl<const N: usize> SegmentedBytes<N>

pub fn with_capacity(capacity: usize) -> SegmentedBytes<N>

Creates a new empty SegmentedBytes with space for capacity segments.

pub fn len(&self) -> usize

Returns the number of bytes contained in this SegmentedBytes.

pub fn is_empty(&self) -> bool

Returns if this SegmentedBytes is empty.

pub fn into_segments(self) -> impl Iterator<Item = MaybeLgBytes>

Consumes self returning an Iterator over all of the non-contiguous segments that make up this buffer.

pub fn into_contiguous(self) -> Vec<u8>

Copies all of the bytes from self returning one contiguous blob.

pub fn push<B: Into<MaybeLgBytes>>(&mut self, b: B)

Extends the buffer by one more segment of MaybeLgBytes.

If the provided MaybeLgBytes is empty, we skip appending it.

pub fn reader(self) -> SegmentedReader<N>

Consumes self returning a type that implements io::Read and io::Seek.

Note: Clone-ing a SegmentedBytes is cheap, so if you need to retain the original SegmentedBytes you should clone it.

Trait Implementations

impl<const N: usize> Buf for SegmentedBytes<N>

fn remaining(&self) -> usize

Returns the number of bytes between the current position and the end of the buffer.

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

Returns a slice starting at the current position and of length between 0 and Buf::remaining(). Note that this can return shorter slice (this allows non-continuous internal representation).

fn advance(&mut self, cnt: usize)

Advance the internal cursor of the Buf

fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize

Fills dst with potentially multiple slices starting at self’s current position.

fn has_remaining(&self) -> bool

Returns true if there are any more bytes to consume

fn copy_to_slice(&mut self, dst: &mut [u8])

Copies bytes from self into dst.

fn get_u8(&mut self) -> u8

Gets an unsigned 8 bit integer from self.

fn get_i8(&mut self) -> i8

Gets a signed 8 bit integer from self.

fn get_u16(&mut self) -> u16

Gets an unsigned 16 bit integer from self in big-endian byte order.

fn get_u16_le(&mut self) -> u16

Gets an unsigned 16 bit integer from self in little-endian byte order.

fn get_u16_ne(&mut self) -> u16

Gets an unsigned 16 bit integer from self in native-endian byte order.

fn get_i16(&mut self) -> i16

Gets a signed 16 bit integer from self in big-endian byte order.

fn get_i16_le(&mut self) -> i16

Gets a signed 16 bit integer from self in little-endian byte order.

fn get_i16_ne(&mut self) -> i16

Gets a signed 16 bit integer from self in native-endian byte order.

fn get_u32(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the big-endian byte order.

fn get_u32_le(&mut self) -> u32

Gets an unsigned 32 bit integer from self in the little-endian byte order.

fn get_u32_ne(&mut self) -> u32

Gets an unsigned 32 bit integer from self in native-endian byte order.

fn get_i32(&mut self) -> i32

Gets a signed 32 bit integer from self in big-endian byte order.

fn get_i32_le(&mut self) -> i32

Gets a signed 32 bit integer from self in little-endian byte order.

fn get_i32_ne(&mut self) -> i32

Gets a signed 32 bit integer from self in native-endian byte order.

fn get_u64(&mut self) -> u64

Gets an unsigned 64 bit integer from self in big-endian byte order.

fn get_u64_le(&mut self) -> u64

Gets an unsigned 64 bit integer from self in little-endian byte order.

fn get_u64_ne(&mut self) -> u64

Gets an unsigned 64 bit integer from self in native-endian byte order.

fn get_i64(&mut self) -> i64

Gets a signed 64 bit integer from self in big-endian byte order.

fn get_i64_le(&mut self) -> i64

Gets a signed 64 bit integer from self in little-endian byte order.

fn get_i64_ne(&mut self) -> i64

Gets a signed 64 bit integer from self in native-endian byte order.

fn get_u128(&mut self) -> u128

Gets an unsigned 128 bit integer from self in big-endian byte order.

fn get_u128_le(&mut self) -> u128

Gets an unsigned 128 bit integer from self in little-endian byte order.

fn get_u128_ne(&mut self) -> u128

Gets an unsigned 128 bit integer from self in native-endian byte order.

fn get_i128(&mut self) -> i128

Gets a signed 128 bit integer from self in big-endian byte order.

fn get_i128_le(&mut self) -> i128

Gets a signed 128 bit integer from self in little-endian byte order.

fn get_i128_ne(&mut self) -> i128

Gets a signed 128 bit integer from self in native-endian byte order.

fn get_uint(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in big-endian byte order.

fn get_uint_le(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in little-endian byte order.

fn get_uint_ne(&mut self, nbytes: usize) -> u64

Gets an unsigned n-byte integer from self in native-endian byte order.

fn get_int(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in big-endian byte order.

fn get_int_le(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in little-endian byte order.

fn get_int_ne(&mut self, nbytes: usize) -> i64

Gets a signed n-byte integer from self in native-endian byte order.

fn get_f32(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in big-endian byte order.

fn get_f32_le(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in little-endian byte order.

fn get_f32_ne(&mut self) -> f32

Gets an IEEE754 single-precision (4 bytes) floating point number from self in native-endian byte order.

fn get_f64(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in big-endian byte order.

fn get_f64_le(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in little-endian byte order.

fn get_f64_ne(&mut self) -> f64

Gets an IEEE754 double-precision (8 bytes) floating point number from self in native-endian byte order.

fn copy_to_bytes(&mut self, len: usize) -> Bytes

Consumes len bytes inside self and returns new instance of Bytes with this data.

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

where Self: Sized,

Creates an adaptor which will read at most limit bytes from self.

fn chain<U>(self, next: U) -> Chain<Self, U>

where U: Buf, Self: Sized,

Creates an adaptor which will chain this buffer with another.

fn reader(self) -> Reader<Self>

where Self: Sized,

Creates an adaptor which implements the Read trait for self.

impl ChunkReader for SegmentedBytes

type T = SegmentedReader

The concrete type of reader returned by this trait

fn get_read(&self, start: u64) -> Result<Self::T>

Get a Read instance starting at the provided file offset

fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes>

Get a range of data in memory as Bytes

impl<const N: usize> Clone for SegmentedBytes<N>

fn clone(&self) -> SegmentedBytes<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for SegmentedBytes<N>

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

Formats the value using the given formatter.

impl Default for SegmentedBytes

fn default() -> Self

Returns the “default value” for a type.

impl From<Bytes> for SegmentedBytes

fn from(value: Bytes) -> Self

Converts to this type from the input type.

impl From<MaybeLgBytes> for SegmentedBytes

fn from(value: MaybeLgBytes) -> Self

Converts to this type from the input type.

impl From<Vec<MaybeLgBytes>> for SegmentedBytes

fn from(value: Vec<MaybeLgBytes>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for SegmentedBytes

fn from(value: Vec<u8>) -> Self

Converts to this type from the input type.

impl<const N: usize> FromIterator<Bytes> for SegmentedBytes<N>

fn from_iter<T: IntoIterator<Item = Bytes>>(iter: T) -> Self

Creates a value from an iterator.

impl<const N: usize> FromIterator<Vec<u8>> for SegmentedBytes<N>

fn from_iter<T: IntoIterator<Item = Vec<u8>>>(iter: T) -> Self

Creates a value from an iterator.

impl Length for SegmentedBytes

fn len(&self) -> u64

Returns the amount of bytes of the inner source.

impl<const N: usize> PartialEq for SegmentedBytes<N>

fn eq(&self, other: &SegmentedBytes<N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> Eq for SegmentedBytes<N>

impl<const N: usize> StructuralPartialEq for SegmentedBytes<N>