Struct opendal::Operator

pub struct Operator { /* private fields */ }

Operator is the user-facing APIs for object and object streams.

Operator needs to be built with Builder.

Implementations

impl Operator

pub fn new<A: Accessor>(acc: A) -> OperatorBuilder<impl Accessor>

Create a new operator.

Examples

Read more backend init examples in examples.

use opendal::services::Fs;
use opendal::Builder;
use opendal::Operator;
#[tokio::main]
async fn main() -> Result<()> {
    // Create fs backend builder.
    let mut builder = Fs::default();
    // Set the root for fs, all operations will happen under this root.
    //
    // NOTE: the root must be absolute path.
    builder.root("/tmp");

    // Build an `Operator` to start operating the storage.
    let op: Operator = Operator::new(builder.build()?).finish();

    // Create an object handle to start operation on object.
    let _ = op.object("test_file");

    Ok(())
}

pub fn create<B: Builder>(ab: B) -> Result<OperatorBuilder<impl Accessor>>

Create a new operator with input builder.

OpenDAL will call builder.build() internally, so we don’t need to import opendal::Builder trait.

Examples

Read more backend init examples in examples.

use opendal::services::Fs;
use opendal::Operator;
#[tokio::main]
async fn main() -> Result<()> {
    // Create fs backend builder.
    let mut builder = Fs::default();
    // Set the root for fs, all operations will happen under this root.
    //
    // NOTE: the root must be absolute path.
    builder.root("/tmp");

    // Build an `Operator` to start operating the storage.
    let op: Operator = Operator::create(builder)?.finish();

    // Create an object handle to start operation on object.
    let _ = op.object("test_file");

    Ok(())
}

pub fn from_map<B: Builder>( map: HashMap<String, String> ) -> Result<OperatorBuilder<impl Accessor>>

Create a new operator from given map.

use std::collections::HashMap;

use opendal::services::Fs;
use opendal::Operator;
#[tokio::main]
async fn main() -> Result<()> {
    let map = HashMap::from([
        // Set the root for fs, all operations will happen under this root.
        //
        // NOTE: the root must be absolute path.
        ("root".to_string(), "/tmp".to_string()),
    ]);

    // Build an `Operator` to start operating the storage.
    let op: Operator = Operator::from_map::<Fs>(map)?.finish();

    // Create an object handle to start operation on object.
    let _ = op.object("test_file");

    Ok(())
}

pub fn from_iter<B: Builder>( iter: impl Iterator<Item = (String, String)> ) -> Result<OperatorBuilder<impl Accessor>>

Create a new operator from iter.

WARNING

It’s better to use from_map. We may remove this API in the future.

pub fn from_env<B: Builder>() -> Result<OperatorBuilder<impl Accessor>>

Create a new operator from env.

WARNING

It’s better to use from_map. We may remove this API in the future.

pub fn inner(&self) -> FusedAccessor

Get inner accessor.

This function should only be used by developers to implement layers.

pub fn layer<L: Layer<FusedAccessor>>(self, layer: L) -> Self

Create a new layer with dynamic dispatch.

Notes

OperatorBuilder::layer() is using static dispatch which is zero cost. Operator::layer() is using dynamic dispatch which has a bit runtime overhead with an extra vtable lookup and unable to inline.

It’s always recommended to use OperatorBuilder::layer() instead.

Examples

use opendal::layers::LoggingLayer;
use opendal::services::Fs;
use opendal::Operator;

let op = Operator::create(Fs::default())?.finish();
let op = op.layer(LoggingLayer::default());
// All operations will go through the new_layer
let _ = op.object("test_file").read().await?;

pub fn metadata(&self) -> OperatorMetadata

Get metadata of underlying accessor.

Examples

use opendal::Operator;

let meta = op.metadata();

pub fn batch(&self) -> BatchOperator

Create a new batch operator handle to take batch operations like walk and remove.

pub fn object(&self, path: &str) -> Object

Create a new Object handle to take operations.

pub async fn check(&self) -> Result<()>

Check if this operator can work correctly.

We will send a list request to path and return any errors we met.

use opendal::Operator;

op.check().await?;

Trait Implementations

impl Clone for Operator

fn clone(&self) -> Operator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Operator

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

Formats the value using the given formatter.

impl From<Arc<dyn Accessor<Pager = Box<dyn Page + 'static, Global>, BlockingPager = Box<dyn BlockingPage + 'static, Global>, BlockingReader = Box<dyn BlockingRead + 'static, Global>, Reader = Box<dyn Read + 'static, Global>> + 'static>> for Operator

fn from(accessor: FusedAccessor) -> Self

Converts to this type from the input type.