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_write_allocated_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.)

In async mode, async functions in DynStorage return boxed futures (Pin<Box<dyn Future>>), which makes them slightly less efficient than async functions in Storage, hence the distinction. In sync mode, they return values directly, so there would be no need for this distinct trait, but we keep it for compatibility between sync and async.

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 as 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 as 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 as for Storage::pure_write_zeroes() apply.

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

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

Safety

Same considerations as for Storage::pure_write_allocated_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 as 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 as 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<()>> + '_>>

Object-safe 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_write_allocated_zeroes( &self, offset: u64, length: u64, ) -> Result<()>

Ensure the given range is allocated, and 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