pub struct Operator { /* private fields */ }
Expand description
User-facing APIs for object and object streams.
Implementations
sourceimpl Operator
impl Operator
sourcepub fn new(accessor: Arc<dyn Accessor>) -> Self
pub fn new(accessor: Arc<dyn Accessor>) -> Self
Create a new operator.
Example
Read more backend init examples in examples.
use std::sync::Arc;
/// Example for initiating a fs backend.
use anyhow::Result;
use opendal::services::fs;
use opendal::services::fs::Builder;
use opendal::Accessor;
use opendal::Object;
use opendal::Operator;
#[tokio::main]
async fn main() -> Result<()> {
// Create fs backend builder.
let mut builder: Builder = fs::Backend::build();
// Set the root for fs, all operations will happen under this root.
//
// NOTE: the root must be absolute path.
builder.root("/tmp");
// Build the `Accessor`.
let accessor: Arc<dyn Accessor> = builder.finish().await?;
// `Accessor` provides the low level APIs, we will use `Operator` normally.
let op: Operator = Operator::new(accessor);
// Create an object handle to start operation on object.
let _: Object = op.object("test_file");
Ok(())
}
sourcepub fn object(&self, path: &str) -> Object
pub fn object(&self, path: &str) -> Object
Create a new object handle to take operations.
Example
use anyhow::Result;
use futures::AsyncReadExt;
use opendal::services::fs;
use opendal::ObjectMode;
use opendal::Operator;
#[tokio::main]
async fn main() -> Result<()> {
let op = Operator::new(fs::Backend::build().root("/tmp").finish().await?);
let o = op.object("test_file");
// Write data info file;
let w = o.writer();
let n = w
.write_bytes("Hello, World!".to_string().into_bytes())
.await?;
assert_eq!(n, 13);
// Read data from file;
let mut r = o.reader();
let mut buf = vec![];
let n = r.read_to_end(&mut buf).await?;
assert_eq!(n, 13);
assert_eq!(String::from_utf8_lossy(&buf), "Hello, World!");
// Read range from file;
let mut r = o.range_reader(10, 1);
let mut buf = vec![];
let n = r.read_to_end(&mut buf).await?;
assert_eq!(n, 1);
assert_eq!(String::from_utf8_lossy(&buf), "l");
// Get file's Metadata
let meta = o.metadata().await?;
assert_eq!(meta.content_length(), 13);
// Delete file.
o.delete().await?;
Ok(())
}
sourcepub fn objects(&self, path: &str) -> ObjectStream
pub fn objects(&self, path: &str) -> ObjectStream
Create a new object stream handle to list objects.
Example
use anyhow::Result;
use futures::StreamExt;
use opendal::ObjectMode;
use opendal::ObjectStream;
use opendal::Operator;
use opendal::services::fs;
#[tokio::main]
async fn main() -> Result<()> {
let op = Operator::new(fs::Backend::build().root("/tmp").finish().await?);
op.object("test_dir/test_file").writer().write_bytes("Hello, World!".to_string().into_bytes()).await?;
// Start listing a dir.
let mut obs: ObjectStream = op.objects("test_dir");
// ObjectStream implements `futures::Stream`
while let Some(o) = obs.next().await {
let mut o = o?;
// It's highly possible that OpenDAL already did metadata during list.
// Use `Object::metadata_cached()` to get cached metadata at first.
let meta = o.metadata_cached().await?;
match meta.mode() {
ObjectMode::FILE => {
println!("Handling file")
}
ObjectMode::DIR => {
println!("Handling dir like start a new list via meta.path()")
}
ObjectMode::Unknown => continue,
}
}
Ok(())
}
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Operator
impl Send for Operator
impl Sync for Operator
impl Unpin for Operator
impl !UnwindSafe for Operator
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
🔬 This is a nightly-only experimental API. (
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more