Trait DynStorage

pub trait DynStorage:
    Any
    + Debug
    + Display
    + Send
    + Sync {
    // Required methods
    fn dyn_mem_align(&self) -> usize;
    fn dyn_req_align(&self) -> usize;
    fn dyn_zero_align(&self) -> usize;
    fn dyn_discard_align(&self) -> usize;
    fn dyn_size(&self) -> Result<u64>;
    fn dyn_resolve_relative_path(&self, relative: &Path) -> Result<PathBuf>;
    fn dyn_get_filename(&self) -> Option<PathBuf>;
    unsafe fn dyn_pure_readv<'a>(
        &'a self,
        bufv: IoVectorMut<'a>,
        offset: u64,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>>;
    unsafe fn dyn_pure_writev<'a>(
        &'a self,
        bufv: IoVector<'a>,
        offset: u64,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>>;
    unsafe fn dyn_pure_write_zeroes(
        &self,
        offset: u64,
        length: u64,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
    unsafe fn dyn_pure_discard(
        &self,
        offset: u64,
        length: u64,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
    fn dyn_flush(&self) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
    fn dyn_sync(&self) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
    unsafe fn dyn_invalidate_cache(
        &self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
    fn dyn_get_storage_helper(&self) -> &CommonStorageHelper;
    fn dyn_resize(
        &self,
        new_size: u64,
        prealloc_mode: PreallocateMode,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>;
}

Allow dynamic use of storage objects (i.e. is object safe).

When using normal Storage objects, they must all be of the same type within a single disk image chain. For example, every storage object underneath a FormatAccess<StdFile> object must be of type StdFile.

DynStorage allows the use of Box<dyn DynStorage>, which implements Storage, to allow mixed storage object types. Therefore, a FormatAccess<Box<dyn DynStorage>> allows e.g. the use of both Box<StdFile> and Box<Null> storage objects together. (Arc instead of Box works, too.)

Async functions in DynStorage return boxed futures (Pin<Box<dyn Future>>), which makes them slighly less efficient than async functions in Storage, hence the distinction.

Required Methods

fn dyn_mem_align(&self) -> usize

Wrapper around Storage::mem_align().

fn dyn_req_align(&self) -> usize

Wrapper around Storage::req_align().

fn dyn_zero_align(&self) -> usize

Wrapper around Storage::zero_align().

fn dyn_discard_align(&self) -> usize

Wrapper around Storage::discard_align().

fn dyn_size(&self) -> Result<u64>

Wrapper around Storage::size().

fn dyn_resolve_relative_path(&self, relative: &Path) -> Result<PathBuf>

Wrapper around Storage::resolve_relative_path().

fn dyn_get_filename(&self) -> Option<PathBuf>

Wrapper around Storage::get_filename()

unsafe fn dyn_pure_readv<'a>( &'a self, bufv: IoVectorMut<'a>, offset: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>>

Object-safe wrapper around Storage::pure_readv().

Safety

Same considerations are for Storage::pure_readv() apply.

unsafe fn dyn_pure_writev<'a>( &'a self, bufv: IoVector<'a>, offset: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'a>>

Object-safe wrapper around Storage::pure_writev().

Safety

Same considerations are for Storage::pure_writev() apply.

unsafe fn dyn_pure_write_zeroes( &self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Object-safe wrapper around Storage::pure_write_zeroes().

Safety

Same considerations are for Storage::pure_write_zeroes() apply.

unsafe fn dyn_pure_discard( &self, offset: u64, length: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Object-safe wrapper around Storage::pure_discard().

Safety

Same considerations are for Storage::pure_discard() apply.

fn dyn_flush(&self) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Object-safe wrapper around Storage::flush().

fn dyn_sync(&self) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Object-safe wrapper around Storage::sync().

unsafe fn dyn_invalidate_cache( &self, ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Object-safe wrapper around Storage::invalidate_cache().

Safety

Same considerations are for Storage::invalidate_cache() apply.

fn dyn_get_storage_helper(&self) -> &CommonStorageHelper

Wrapper around Storage::get_storage_helper().

fn dyn_resize( &self, new_size: u64, prealloc_mode: PreallocateMode, ) -> Pin<Box<dyn Future<Output = Result<()>> + '_>>

Wrapper around Storage::resize().

Trait Implementations

impl Storage for Box<dyn DynStorage>

async fn open(opts: StorageOpenOptions) -> Result<Self>

Open a storage object.

async fn create_open(opts: StorageCreateOptions) -> Result<Self>

Create a storage object and open it.

fn mem_align(&self) -> usize

Minimum required alignment for memory buffers.

fn req_align(&self) -> usize

Minimum required alignment for offsets and lengths.

fn zero_align(&self) -> usize

Minimum required alignment for zero writes.

fn discard_align(&self) -> usize

Minimum required alignment for effective discards.

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

Storage object length.

fn resolve_relative_path<P: AsRef<Path>>(&self, relative: P) -> Result<PathBuf>

Resolve the given path relative to this storage object.

fn get_filename(&self) -> Option<PathBuf>

Return a filename, if possible.

async unsafe fn pure_readv( &self, bufv: IoVectorMut<'_>, offset: u64, ) -> Result<()>

Read data at offset into bufv.

async unsafe fn pure_writev( &self, bufv: IoVector<'_>, offset: u64, ) -> Result<()>

Write data from bufv to offset.

async unsafe fn pure_write_zeroes(&self, offset: u64, length: u64) -> Result<()>

Ensure the given range reads back as zeroes.

async unsafe fn pure_discard(&self, offset: u64, length: u64) -> Result<()>

Discard the given range, with undefined contents when read back.

async fn flush(&self) -> Result<()>

Flush internal buffers.

async fn sync(&self) -> Result<()>

Sync data already written to the storage hardware.

async unsafe fn invalidate_cache(&self) -> Result<()>

Drop internal buffers.

fn get_storage_helper(&self) -> &CommonStorageHelper

Return the storage helper object (used by the StorageExt implementation).

async fn resize( &self, new_size: u64, prealloc_mode: PreallocateMode, ) -> Result<()>

Resize to the given size.

fn open_sync(opts: StorageOpenOptions) -> Result<Self>

Synchronous wrapper around Storage::open().

async fn create(opts: StorageCreateOptions) -> Result<()>

Create a storage object.

Implementors

impl<S: Storage + 'static> DynStorage for S