Struct opendal::raw::adapters::kv::Backend

pub struct Backend<S: Adapter> { /* private fields */ }

Backend of kv service. If the storage service is one k-v-like service, it should implement this kv Backend by right.

Backend implements one general logic on how to read, write, scan the data from one kv store efficiently. And the Adapter held by Backend will handle how to communicate with one k-v-like service really and provides a series of basic operation for this service.

OpenDAL developer can implement one new k-v store backend easily with help of this Backend.

Implementations

impl<S> Backend<S>

where S: Adapter,

pub fn new(kv: S) -> Self

Create a new kv backend.

pub fn with_root(self, root: &str) -> Self

Configure root within this backend.

Trait Implementations

impl<S: Adapter> Accessor for Backend<S>

type Reader = Buffer

Reader is the associated reader returned in read operation.

type BlockingReader = Buffer

BlockingReader is the associated reader returned blocking_read operation.

type Writer = KvWriter<S>

Writer is the associated writer returned in write operation.

type BlockingWriter = KvWriter<S>

BlockingWriter is the associated writer returned blocking_write operation.

type Lister = HierarchyLister<KvLister>

Lister is the associated lister returned in list operation.

type BlockingLister = HierarchyLister<KvLister>

BlockingLister is the associated lister returned blocking_list operation.

fn info(&self) -> AccessorInfo

Invoke the info operation to get metadata of accessor.

fn read<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, __arg2: OpRead ) -> Pin<Box<dyn Future<Output = Result<(RpRead, Self::Reader)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

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

Invoke the blocking_read operation on the specified path.

fn write<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, __arg2: OpWrite ) -> Pin<Box<dyn Future<Output = Result<(RpWrite, Self::Writer)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

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

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

Invoke the blocking_write operation on the specified path.

fn stat<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, __arg2: OpStat ) -> Pin<Box<dyn Future<Output = Result<RpStat>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Invoke the stat operation on the specified path.

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

Invoke the blocking_stat operation on the specified path.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, __arg2: OpDelete ) -> Pin<Box<dyn Future<Output = Result<RpDelete>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Invoke the delete operation on the specified path.

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

Invoke the blocking_delete operation on the specified path.

fn list<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, args: OpList ) -> Pin<Box<dyn Future<Output = Result<(RpList, Self::Lister)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Invoke the list 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 create_dir<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, args: OpCreateDir ) -> Pin<Box<dyn Future<Output = Result<RpCreateDir>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Invoke the create operation on the specified path

fn copy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, args: OpCopy ) -> Pin<Box<dyn Future<Output = Result<RpCopy>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn rename<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, args: OpRename ) -> Pin<Box<dyn Future<Output = Result<RpRename>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

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

fn presign<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, args: OpPresign ) -> Pin<Box<dyn Future<Output = Result<RpPresign>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Invoke the presign operation on the specified path.

fn batch<'life0, 'async_trait>( &'life0 self, args: OpBatch ) -> Pin<Box<dyn Future<Output = Result<RpBatch>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

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_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.

impl<S: Clone + Adapter> Clone for Backend<S>

fn clone(&self) -> Backend<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + Adapter> Debug for Backend<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.