Struct opendal::OperatorBuilder

pub struct OperatorBuilder<A: Accessor> { /* private fields */ }

OperatorBuilder is a typed builder to builder an Operator.

Notes

OpenDAL uses static dispatch internally and only perform dynamic dispatch at the outmost type erase layer. OperatorBuilder is the only public API provided by OpenDAL come with generic parameters.

It’s required to call finish after the operator built.

Examples

For users who want to support many services, we can build a helper function like the following:

use std::collections::HashMap;

use opendal::layers::LoggingLayer;
use opendal::layers::RetryLayer;
use opendal::services;
use opendal::Builder;
use opendal::Operator;
use opendal::Result;
use opendal::Scheme;

fn init_service<B: Builder>(cfg: HashMap<String, String>) -> Result<Operator> {
    let op = Operator::from_map::<B>(cfg)?
        .layer(LoggingLayer::default())
        .layer(RetryLayer::new())
        .finish();

    Ok(op)
}

async fn init(scheme: Scheme, cfg: HashMap<String, String>) -> Result<()> {
    let _ = match scheme {
        Scheme::S3 => init_service::<services::S3>(cfg)?,
        Scheme::Fs => init_service::<services::Fs>(cfg)?,
        _ => todo!(),
    };

    Ok(())
}

Implementations

impl<A: Accessor> OperatorBuilder<A>

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

Create a new operator builder.

pub fn layer<L: Layer<A>>(self, layer: L) -> OperatorBuilder<L::LayeredAccessor>

Create a new layer with static 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::new(Fs::default())?
    .layer(LoggingLayer::default())
    .finish();
// All operations will go through the new_layer
let _ = op.read("test_file").await?;

pub fn finish(self) -> Operator

Finish the building to construct an Operator.