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

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

Backend of kv service.

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>

Reader 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 or scan operation.

type BlockingPager = KvPager

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

fn info(&self) -> AccessorInfo

Invoke the info operation to get metadata of accessor.

fn create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    __arg2: OpCreate
) -> Pin<Box<dyn Future<Output = Result<RpCreate>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the create operation on the specified path

fn blocking_create(&self, path: &str, _: OpCreate) -> Result<RpCreate>

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 scan<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    __arg2: OpScan
) -> Pin<Box<dyn Future<Output = Result<(RpScan, Self::Pager)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the scan operation on the specified path.

fn blocking_scan(
    &self,
    path: &str,
    _: OpScan
) -> Result<(RpScan, Self::BlockingPager)>

Invoke the blocking_scan 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 presign(&self, path: &str, args: OpPresign) -> Result<RpPresign>

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_list(
    &self,
    path: &str,
    args: OpList
) -> Result<(RpList, Self::BlockingPager)>

Invoke the blocking_list operation on the specified 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.