Trait opendal::raw::AccessDyn

pub trait AccessDyn: Send + Sync + Debug + Unpin {
    // Required methods
    fn info_dyn(&self) -> AccessorInfo;
    fn create_dir_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpCreateDir
    ) -> BoxedFuture<'a, Result<RpCreateDir>>;
    fn stat_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpStat
    ) -> BoxedFuture<'a, Result<RpStat>>;
    fn read_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpRead
    ) -> BoxedFuture<'a, Result<(RpRead, Reader)>>;
    fn write_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpWrite
    ) -> BoxedFuture<'a, Result<(RpWrite, Writer)>>;
    fn delete_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpDelete
    ) -> BoxedFuture<'a, Result<RpDelete>>;
    fn list_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpList
    ) -> BoxedFuture<'a, Result<(RpList, Lister)>>;
    fn copy_dyn<'a>(
        &'a self,
        from: &'a str,
        to: &'a str,
        args: OpCopy
    ) -> BoxedFuture<'a, Result<RpCopy>>;
    fn rename_dyn<'a>(
        &'a self,
        from: &'a str,
        to: &'a str,
        args: OpRename
    ) -> BoxedFuture<'a, Result<RpRename>>;
    fn presign_dyn<'a>(
        &'a self,
        path: &'a str,
        args: OpPresign
    ) -> BoxedFuture<'a, Result<RpPresign>>;
    fn batch_dyn(&self, args: OpBatch) -> BoxedFuture<'_, Result<RpBatch>>;
    fn blocking_create_dir_dyn(
        &self,
        path: &str,
        args: OpCreateDir
    ) -> Result<RpCreateDir>;
    fn blocking_stat_dyn(&self, path: &str, args: OpStat) -> Result<RpStat>;
    fn blocking_read_dyn(
        &self,
        path: &str,
        args: OpRead
    ) -> Result<(RpRead, BlockingReader)>;
    fn blocking_write_dyn(
        &self,
        path: &str,
        args: OpWrite
    ) -> Result<(RpWrite, BlockingWriter)>;
    fn blocking_delete_dyn(
        &self,
        path: &str,
        args: OpDelete
    ) -> Result<RpDelete>;
    fn blocking_list_dyn(
        &self,
        path: &str,
        args: OpList
    ) -> Result<(RpList, BlockingLister)>;
    fn blocking_copy_dyn(
        &self,
        from: &str,
        to: &str,
        args: OpCopy
    ) -> Result<RpCopy>;
    fn blocking_rename_dyn(
        &self,
        from: &str,
        to: &str,
        args: OpRename
    ) -> Result<RpRename>;
}

AccessDyn is the dyn version of Access make it possible to use as Box<dyn AccessDyn>.

Required Methods

fn info_dyn(&self) -> AccessorInfo

Dyn version of Accessor::info

fn create_dir_dyn<'a>( &'a self, path: &'a str, args: OpCreateDir ) -> BoxedFuture<'a, Result<RpCreateDir>>

Dyn version of Accessor::create_dir

fn stat_dyn<'a>( &'a self, path: &'a str, args: OpStat ) -> BoxedFuture<'a, Result<RpStat>>

Dyn version of Accessor::stat

fn read_dyn<'a>( &'a self, path: &'a str, args: OpRead ) -> BoxedFuture<'a, Result<(RpRead, Reader)>>

Dyn version of Accessor::read

fn write_dyn<'a>( &'a self, path: &'a str, args: OpWrite ) -> BoxedFuture<'a, Result<(RpWrite, Writer)>>

Dyn version of Accessor::write

fn delete_dyn<'a>( &'a self, path: &'a str, args: OpDelete ) -> BoxedFuture<'a, Result<RpDelete>>

Dyn version of Accessor::delete

fn list_dyn<'a>( &'a self, path: &'a str, args: OpList ) -> BoxedFuture<'a, Result<(RpList, Lister)>>

Dyn version of Accessor::list

fn copy_dyn<'a>( &'a self, from: &'a str, to: &'a str, args: OpCopy ) -> BoxedFuture<'a, Result<RpCopy>>

Dyn version of Accessor::copy

fn rename_dyn<'a>( &'a self, from: &'a str, to: &'a str, args: OpRename ) -> BoxedFuture<'a, Result<RpRename>>

Dyn version of Accessor::rename

fn presign_dyn<'a>( &'a self, path: &'a str, args: OpPresign ) -> BoxedFuture<'a, Result<RpPresign>>

Dyn version of Accessor::presign

fn batch_dyn(&self, args: OpBatch) -> BoxedFuture<'_, Result<RpBatch>>

Dyn version of Accessor::batch

fn blocking_create_dir_dyn( &self, path: &str, args: OpCreateDir ) -> Result<RpCreateDir>

Dyn version of Accessor::blocking_create_dir

fn blocking_stat_dyn(&self, path: &str, args: OpStat) -> Result<RpStat>

Dyn version of Accessor::blocking_stat

fn blocking_read_dyn( &self, path: &str, args: OpRead ) -> Result<(RpRead, BlockingReader)>

Dyn version of Accessor::blocking_read

fn blocking_write_dyn( &self, path: &str, args: OpWrite ) -> Result<(RpWrite, BlockingWriter)>

Dyn version of Accessor::blocking_write

fn blocking_delete_dyn(&self, path: &str, args: OpDelete) -> Result<RpDelete>

Dyn version of Accessor::blocking_delete

fn blocking_list_dyn( &self, path: &str, args: OpList ) -> Result<(RpList, BlockingLister)>

Dyn version of Accessor::blocking_list

fn blocking_copy_dyn( &self, from: &str, to: &str, args: OpCopy ) -> Result<RpCopy>

Dyn version of Accessor::blocking_copy

fn blocking_rename_dyn( &self, from: &str, to: &str, args: OpRename ) -> Result<RpRename>

Dyn version of Accessor::blocking_rename

Trait Implementations

impl Access for dyn AccessDyn

type Reader = Box<dyn ReadDyn>

Reader is the associated reader returned in read operation.

type BlockingReader = Box<dyn BlockingRead>

BlockingReader is the associated reader returned blocking_read operation.

type Writer = Box<dyn WriteDyn>

Writer is the associated writer returned in write operation.

type BlockingWriter = Box<dyn BlockingWrite>

BlockingWriter is the associated writer returned blocking_write operation.

type Lister = Box<dyn ListDyn>

Lister is the associated lister returned in list operation.

type BlockingLister = Box<dyn BlockingList>

BlockingLister is the associated lister returned blocking_list operation.

fn info(&self) -> AccessorInfo

Invoke the info operation to get metadata of accessor.

async fn create_dir(&self, path: &str, args: OpCreateDir) -> Result<RpCreateDir>

Invoke the create operation on the specified path

async fn stat(&self, path: &str, args: OpStat) -> Result<RpStat>

Invoke the stat operation on the specified path.

async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)>

Invoke the read operation on the specified path, returns a Reader if operate successful.

async fn write( &self, path: &str, args: OpWrite ) -> Result<(RpWrite, Self::Writer)>

Invoke the write operation on the specified path, returns a written size if operate successful.

async fn delete(&self, path: &str, args: OpDelete) -> Result<RpDelete>

Invoke the delete operation on the specified path.

async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)>

Invoke the list operation on the specified path.

async fn copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy>

Invoke the copy operation on the specified from path and to path.

async fn rename(&self, from: &str, to: &str, args: OpRename) -> Result<RpRename>

Invoke the rename operation on the specified from path and to path.

async fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign>

Invoke the presign operation on the specified path.

fn batch( &self, args: OpBatch ) -> impl Future<Output = Result<RpBatch>> + MaybeSend

Invoke the batch operations.

fn blocking_create_dir( &self, path: &str, args: OpCreateDir ) -> Result<RpCreateDir>

Invoke the blocking_create operation on the specified path.

fn blocking_read( &self, path: &str, args: OpRead ) -> Result<(RpRead, Self::BlockingReader)>

Invoke the blocking_read operation on the specified path.

fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat>

Invoke the blocking_stat operation on the specified path.

fn blocking_write( &self, path: &str, args: OpWrite ) -> Result<(RpWrite, Self::BlockingWriter)>

Invoke the blocking_write operation on the specified path.

fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete>

Invoke the blocking_delete operation on the specified path.

fn blocking_list( &self, path: &str, args: OpList ) -> Result<(RpList, Self::BlockingLister)>

Invoke the blocking_list operation on the specified path.

fn blocking_copy(&self, from: &str, to: &str, args: OpCopy) -> Result<RpCopy>

Invoke the blocking_copy operation on the specified from path and to path.

fn blocking_rename( &self, from: &str, to: &str, args: OpRename ) -> Result<RpRename>

Invoke the blocking_rename operation on the specified from path and to path.

Implementors

impl<A> AccessDyn for A

where A: Access<Reader = Reader, BlockingReader = BlockingReader, Writer = Writer, BlockingWriter = BlockingWriter, Lister = Lister, BlockingLister = BlockingLister> + ?Sized,