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 = Cursor

Reader is the associated reader the could return in read operation.

type BlockingReader = Cursor

BlockingReader is the associated reader that could return in blocking_read operation.

type Writer = KvWriter<S>

Writer is the associated writer the could return in write operation.

type BlockingWriter = KvWriter<S>

BlockingWriter is the associated writer the could return in blocking_write operation.

type Pager = KvPager

Pager is the associated page that return in list operation.

type BlockingPager = KvPager

BlockingPager is the associated pager that could return in blocking_list operation.

fn info(&self) -> AccessorInfo

Invoke the info operation to get metadata of accessor.

fn create_dir<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, __arg2: 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 blocking_create_dir(&self, path: &str, _: OpCreateDir) -> Result<RpCreateDir>

Invoke the blocking_create operation on the specified path.

fn read<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, args: 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, args: 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::Pager)>> + 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::BlockingPager)>

Invoke the blocking_list operation on the specified path.

fn rename<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, __arg3: 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 blocking_rename(&self, from: &str, to: &str, _: OpRename) -> Result<RpRename>

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

fn copy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, __arg3: 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 blocking_copy(&self, from: &str, to: &str, _: OpCopy) -> Result<RpCopy>

Invoke the blocking_copy 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.

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.