pub trait Layer<A: Access> {
type LayeredAccess: Access;
// Required method
fn layer(&self, inner: A) -> Self::LayeredAccess;
}Expand description
Layer is used to intercept the operations on the underlying storage.
Struct that implement this trait must accept input Arc<dyn Accessor> as inner,
and returns a new Arc<dyn Accessor> as output.
All functions in Accessor requires &self, so it’s implementer’s responsibility
to maintain the internal mutability. Please also keep in mind that Accessor
requires Send and Sync.
§Notes
§Inner
It’s required to implement fn inner() -> Option<Arc<dyn Accessor>> for layer’s accessors.
By implement this method, all API calls will be forwarded to inner accessor instead.
§Examples
use std::sync::Arc;
use opendal::raw::*;
use opendal::*;
/// Implement the real accessor logic here.
#[derive(Debug)]
struct TraceAccessor<A: Access> {
inner: A,
}
impl<A: Access> LayeredAccess for TraceAccessor<A> {
type Inner = A;
type Reader = A::Reader;
type Writer = A::Writer;
type Lister = A::Lister;
type Deleter = A::Deleter;
fn inner(&self) -> &Self::Inner {
&self.inner
}
async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
self.inner.read(path, args).await
}
async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
self.inner.write(path, args).await
}
async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Lister)> {
self.inner.list(path, args).await
}
async fn delete(&self) -> Result<(RpDelete, Self::Deleter)> {
self.inner.delete().await
}
}
/// The public struct that exposed to users.
///
/// Will be used like `op.layer(TraceLayer)`
struct TraceLayer;
impl<A: Access> Layer<A> for TraceLayer {
type LayeredAccess = TraceAccessor<A>;
fn layer(&self, inner: A) -> Self::LayeredAccess {
TraceAccessor { inner }
}
}Required Associated Types§
Sourcetype LayeredAccess: Access
type LayeredAccess: Access
The layered accessor that returned by this layer.
Required Methods§
Sourcefn layer(&self, inner: A) -> Self::LayeredAccess
fn layer(&self, inner: A) -> Self::LayeredAccess
Intercept the operations on the underlying storage.