Trait LayeredAccess 

pub trait LayeredAccess:
    Send
    + Sync
    + Debug
    + Unpin
    + 'static {
    type Inner: Access;
    type Reader: Read;
    type Writer: Write;
    type Lister: List;
    type Deleter: Delete;

    // Required methods
    fn inner(&self) -> &Self::Inner;
    fn read(
        &self,
        path: &str,
        args: OpRead,
    ) -> impl Future<Output = Result<(RpRead, Self::Reader), Error>> + MaybeSend;
    fn write(
        &self,
        path: &str,
        args: OpWrite,
    ) -> impl Future<Output = Result<(RpWrite, Self::Writer), Error>> + MaybeSend;
    fn delete(
        &self,
    ) -> impl Future<Output = Result<(RpDelete, Self::Deleter), Error>> + MaybeSend;
    fn list(
        &self,
        path: &str,
        args: OpList,
    ) -> impl Future<Output = Result<(RpList, Self::Lister), Error>> + MaybeSend;

    // Provided methods
    fn info(&self) -> Arc<AccessorInfo> { ... }
    fn create_dir(
        &self,
        path: &str,
        args: OpCreateDir,
    ) -> impl Future<Output = Result<RpCreateDir, Error>> + MaybeSend { ... }
    fn copy(
        &self,
        from: &str,
        to: &str,
        args: OpCopy,
    ) -> impl Future<Output = Result<RpCopy, Error>> + MaybeSend { ... }
    fn rename(
        &self,
        from: &str,
        to: &str,
        args: OpRename,
    ) -> impl Future<Output = Result<RpRename, Error>> + MaybeSend { ... }
    fn stat(
        &self,
        path: &str,
        args: OpStat,
    ) -> impl Future<Output = Result<RpStat, Error>> + MaybeSend { ... }
    fn presign(
        &self,
        path: &str,
        args: OpPresign,
    ) -> impl Future<Output = Result<RpPresign, Error>> + MaybeSend { ... }
}

LayeredAccess is layered accessor that forward all not implemented method to inner.

Required Associated Types

type Inner: Access

type Reader: Read

type Writer: Write

type Lister: List

type Deleter: Delete

Required Methods

fn inner(&self) -> &Self::Inner

fn read( &self, path: &str, args: OpRead, ) -> impl Future<Output = Result<(RpRead, Self::Reader), Error>> + MaybeSend

fn write( &self, path: &str, args: OpWrite, ) -> impl Future<Output = Result<(RpWrite, Self::Writer), Error>> + MaybeSend

fn delete( &self, ) -> impl Future<Output = Result<(RpDelete, Self::Deleter), Error>> + MaybeSend

fn list( &self, path: &str, args: OpList, ) -> impl Future<Output = Result<(RpList, Self::Lister), Error>> + MaybeSend

Provided Methods

fn info(&self) -> Arc<AccessorInfo>

fn create_dir( &self, path: &str, args: OpCreateDir, ) -> impl Future<Output = Result<RpCreateDir, Error>> + MaybeSend

fn copy( &self, from: &str, to: &str, args: OpCopy, ) -> impl Future<Output = Result<RpCopy, Error>> + MaybeSend

fn rename( &self, from: &str, to: &str, args: OpRename, ) -> impl Future<Output = Result<RpRename, Error>> + MaybeSend

fn stat( &self, path: &str, args: OpStat, ) -> impl Future<Output = Result<RpStat, Error>> + MaybeSend

fn presign( &self, path: &str, args: OpPresign, ) -> impl Future<Output = Result<RpPresign, Error>> + MaybeSend

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<A, I> LayeredAccess for MetricsAccessor<A, I>

where A: Access, I: MetricsIntercept,

type Inner = A

type Reader = MetricsWrapper<<A as Access>::Reader, I>

type Writer = MetricsWrapper<<A as Access>::Writer, I>

type Lister = MetricsWrapper<<A as Access>::Lister, I>

type Deleter = MetricsWrapper<<A as Access>::Deleter, I>

impl<A: Access> LayeredAccess for MockAccessor<A>

type Inner = A

type Reader = MockReader

type Writer = MockWriter

type Lister = MockLister

type Deleter = MockDeleter

impl<I: Access, C: Access> LayeredAccess for LruCacheAccess<I, C>

type Inner = I

type Reader = Box<dyn ReadDyn>

type Writer = <I as Access>::Writer

type Lister = <I as Access>::Lister

type Deleter = CacheAwareDeleter<C, <I as Access>::Deleter>