Enum MemOrFile

pub enum MemOrFile<M, F> {
    Mem(M),
    File(F),
}

This is a general purpose Either, just like Result, except that the two cases are Mem for something that is in memory, and File for something that is somewhere external and only available via io.

Variants

Mem(M)

We got it all in memory

File(F)

A file

Implementations

impl<M, F> MemOrFile<M, (F, u64)>

where M: AsRef<[u8]>,

Helper methods for a common way to use MemOrFile, where the memory part is something like a slice, and the file part is a tuple consisiting of path or file and size.

pub fn size(&self) -> u64

Get the size of the MemOrFile

impl<M, F> MemOrFile<M, F>

pub fn as_ref(&self) -> MemOrFile<&M, &F>

Turn a reference to a MemOrFile into a MemOrFile of references

pub fn is_mem(&self) -> bool

True if this is a Mem

pub fn mem(&self) -> Option<&M>

Get the mem part

pub fn map_file<F2>(self, f: impl FnOnce(F) -> F2) -> MemOrFile<M, F2>

Map the file part of this MemOrFile

pub fn try_map_file<F2, E>( self, f: impl FnOnce(F) -> Result<F2, E>, ) -> Result<MemOrFile<M, F2>, E>

Try to map the file part of this MemOrFile

pub fn map_mem<M2>(self, f: impl FnOnce(M) -> M2) -> MemOrFile<M2, F>

Map the memory part of this MemOrFile

Trait Implementations

impl<M: Clone, F: Clone> Clone for MemOrFile<M, F>

fn clone(&self) -> MemOrFile<M, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug, F: Debug> Debug for MemOrFile<M, F>

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

Formats the value using the given formatter.

impl<M: Default, F> Default for MemOrFile<M, F>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, M, F> Deserialize<'de> for MemOrFile<M, F>

where M: Deserialize<'de>, F: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M: PartialEq, F: PartialEq> PartialEq for MemOrFile<M, F>

fn eq(&self, other: &MemOrFile<M, F>) -> 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 ReadAt for MemOrFile<Bytes, File>

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

Reads bytes from an offset in this source into a buffer, returning how many bytes were read.

fn read_exact_at(&self, pos: u64, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf from an offset.

impl<M, F> ReadBytesAt for MemOrFile<M, F>

where M: ReadBytesAt, F: ReadBytesAt,

fn read_bytes_at(&self, offset: u64, size: usize) -> Result<Bytes>

Version of ReadAt::read_exact_at that returns a Bytes instead of reading into a buffer.

impl<M, F> Serialize for MemOrFile<M, F>

where M: Serialize, F: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Size for MemOrFile<Bytes, File>

fn size(&self) -> Result<Option<u64>>

Get the size of this object, in bytes.

impl<M: Eq, F: Eq> Eq for MemOrFile<M, F>

impl<M, F> StructuralPartialEq for MemOrFile<M, F>