Struct opendal::Object

pub struct Object { /* private fields */ }

Handler for all object related operations.

Implementations

impl Object

pub fn new(acc: Arc<dyn Accessor>, path: &str) -> Self

Creates a new Object.

pub fn reader(&self) -> Reader

Create a new reader which can read the whole object.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").writer().write_bytes(bs).await?;

    // Read whole file.
    let mut r = op.object("test").reader();
    io::copy(&mut r, &mut io::sink()).await?;

    Ok(())
}

pub fn range_reader(&self, offset: u64, size: u64) -> Reader

Create a new ranged reader which can only read data between [offset, offset+size).

Note

The input offset and size are not checked, callers could meet error while reading.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").writer().write_bytes(bs).await?;

    // Read within [1, 2) bytes.
    let mut r = op.object("test").range_reader(1, 1);
    io::copy(&mut r, &mut io::sink()).await?;

    Ok(())
}

pub fn offset_reader(&self, offset: u64) -> Reader

Create a new offset reader which can read data since offset.

Note

The input offset is not checked, callers could meet error while reading.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").writer().write_bytes(bs).await?;

    // Read start offset 4.
    let mut r = op.object("test").offset_reader(4);
    io::copy(&mut r, &mut io::sink()).await?;

    Ok(())
}

pub fn limited_reader(&self, size: u64) -> Reader

Create a new limited reader which can only read limited data.

Note

The input size is not checked, callers could meet error while reading.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").writer().write_bytes(bs).await?;

    // Read within 8 bytes.
    let mut r = op.object("test").limited_reader(8);
    io::copy(&mut r, &mut io::sink()).await?;

    Ok(())
}

pub fn writer(&self) -> Writer

Create a new writer which can write data into the object.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").writer().write_bytes(bs).await?;

    Ok(())
}

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

Delete current object.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    let bs = "Hello, World!".as_bytes().to_vec();
    op.object("test").delete().await?;

    Ok(())
}

pub async fn metadata(&self) -> Result<Metadata>

Get current object’s metadata.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;
use opendal::error::Kind;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);

    if let Err(e) =  op.object("test").metadata().await {
        if e.kind() == Kind::ObjectNotExist {
            println!("object not exist")
        }
    }

    Ok(())
}

pub async fn metadata_cached(&mut self) -> Result<&Metadata>

Use local cached metadata if possible.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;
use opendal::error::Kind;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);
    let mut o = op.object("test");

    o.metadata_cached().await;
    // The second call to metadata_cached will have no cost.
    o.metadata_cached().await;

    Ok(())
}

pub async fn is_exist(&self) -> Result<bool>

Check if this object exist or not.

Example

use opendal::services::memory;
use anyhow::Result;
use futures::io;
use opendal::Operator;
use opendal::error::Kind;

#[tokio::main]
async fn main() -> Result<()> {
    let op = Operator::new(memory::Backend::build().finish().await?);
    let _ = op.object("test").is_exist().await?;

    Ok(())
}

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the value using the given formatter.