Struct OperatorFuture 

pub struct OperatorFuture<I, O, F>
where
    F: Future<Output = Result<O, Error>>,
{ /* private fields */ }

OperatorFuture is the future generated by Operator.

The future will consume all the input to generate a future.

NOTES

This struct is by design to keep in crate. We don’t want users to use this struct directly.

Implementations

impl<F> OperatorFuture<StatOptions, Metadata, F>

where F: Future<Output = Result<Metadata, Error>>,

pub fn if_match(self, v: &str) -> OperatorFuture<StatOptions, Metadata, F>

Set the If-Match for this operation.

Refer to options::StatOptions::if_match for more details.

pub fn if_none_match(self, v: &str) -> OperatorFuture<StatOptions, Metadata, F>

Set the If-None-Match for this operation.

Refer to options::StatOptions::if_none_match for more details.

pub fn if_modified_since( self, v: Timestamp, ) -> OperatorFuture<StatOptions, Metadata, F>

Set the If-Modified-Since for this operation.

Refer to options::StatOptions::if_modified_since for more details.

pub fn if_unmodified_since( self, v: Timestamp, ) -> OperatorFuture<StatOptions, Metadata, F>

Set the If-Unmodified-Since for this operation.

Refer to options::StatOptions::if_unmodified_since for more details.

pub fn version(self, v: &str) -> OperatorFuture<StatOptions, Metadata, F>

Set the version for this operation.

Refer to options::StatOptions::version for more details.

impl<F> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

where F: Future<Output = Result<PresignedRequest, Error>>,

pub fn override_content_disposition( self, v: &str, ) -> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

Refer to options::StatOptions::override_content_disposition for more details.

pub fn override_cache_control( self, v: &str, ) -> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

Refer to options::StatOptions::override_cache_control for more details.

pub fn override_content_type( self, v: &str, ) -> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

Refer to options::StatOptions::override_content_type for more details.

pub fn if_match( self, v: &str, ) -> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

Refer to options::StatOptions::if_match for more details.

pub fn if_none_match( self, v: &str, ) -> OperatorFuture<(StatOptions, Duration), PresignedRequest, F>

Refer to options::StatOptions::if_none_match for more details.

impl<F> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

where F: Future<Output = Result<PresignedRequest, Error>>,

pub fn override_content_disposition( self, v: &str, ) -> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

Refer to options::ReadOptions::override_content_disposition for more details.

pub fn override_cache_control( self, v: &str, ) -> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

Refer to options::ReadOptions::override_cache_control for more details.

pub fn override_content_type( self, v: &str, ) -> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

Refer to options::ReadOptions::override_content_type for more details.

pub fn if_match( self, v: &str, ) -> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

Refer to options::ReadOptions::if_match for more details.

pub fn if_none_match( self, v: &str, ) -> OperatorFuture<(ReadOptions, Duration), PresignedRequest, F>

Refer to options::ReadOptions::if_none_match for more details.

impl<F> OperatorFuture<(WriteOptions, Duration), PresignedRequest, F>

where F: Future<Output = Result<PresignedRequest, Error>>,

pub fn content_type( self, v: &str, ) -> OperatorFuture<(WriteOptions, Duration), PresignedRequest, F>

Refer to options::WriteOptions::content_type for more details.

pub fn content_disposition( self, v: &str, ) -> OperatorFuture<(WriteOptions, Duration), PresignedRequest, F>

Refer to options::WriteOptions::content_disposition for more details.

pub fn content_encoding( self, v: &str, ) -> OperatorFuture<(WriteOptions, Duration), PresignedRequest, F>

Refer to options::WriteOptions::content_encoding for more details.

pub fn cache_control( self, v: &str, ) -> OperatorFuture<(WriteOptions, Duration), PresignedRequest, F>

Refer to options::WriteOptions::cache_control for more details.

impl<F> OperatorFuture<ReadOptions, Buffer, F>

where F: Future<Output = Result<Buffer, Error>>,

pub fn range( self, range: impl RangeBounds<u64>, ) -> OperatorFuture<ReadOptions, Buffer, F>

Set range for this read request.

If we have a file with size n.

• .. means read bytes in range [0, n) of file.
• 0..1024 and ..1024 means read bytes in range [0, 1024) of file
• 1024.. means read bytes in range [1024, n) of file

let bs = op.read_with("path/to/file").range(0..1024).await?;

pub fn concurrent( self, concurrent: usize, ) -> OperatorFuture<ReadOptions, Buffer, F>

Set concurrent for the reader.

OpenDAL by default to write file without concurrent. This is not efficient for cases when users read large chunks of data. By setting concurrent, opendal will read files concurrently on support storage services.

By setting concurrent, opendal will fetch chunks concurrently with the given chunk size.

let r = op.read_with("path/to/file").concurrent(8).await?;

pub fn chunk(self, chunk_size: usize) -> OperatorFuture<ReadOptions, Buffer, F>

OpenDAL will use services’ preferred chunk size by default. Users can set chunk based on their own needs.

This following example will make opendal read data in 4MiB chunks:

let r = op.read_with("path/to/file").chunk(4 * 1024 * 1024).await?;

pub fn version(self, v: &str) -> OperatorFuture<ReadOptions, Buffer, F>

Set version for this read request.

This feature can be used to retrieve the data of a specified version of the given path.

If the version doesn’t exist, an error with kind ErrorKind::NotFound will be returned.

let mut bs = op.read_with("path/to/file").version(version).await?;

pub fn if_match(self, v: &str) -> OperatorFuture<ReadOptions, Buffer, F>

Set if_match for this read request.

This feature can be used to check if the file’s ETag matches the given ETag.

If file exists and it’s etag doesn’t match, an error with kind ErrorKind::ConditionNotMatch will be returned.

use opendal_core::Operator;
let mut metadata = op.read_with("path/to/file").if_match(etag).await?;

pub fn if_none_match(self, v: &str) -> OperatorFuture<ReadOptions, Buffer, F>

Set if_none_match for this read request.

This feature can be used to check if the file’s ETag doesn’t match the given ETag.

If file exists and it’s etag match, an error with kind ErrorKind::ConditionNotMatch will be returned.

use opendal_core::Operator;
let mut metadata = op.read_with("path/to/file").if_none_match(etag).await?;

pub fn if_modified_since( self, v: impl Into<Timestamp>, ) -> OperatorFuture<ReadOptions, Buffer, F>

if_modified_since

Set if_modified_since for this read request.

This feature can be used to check if the file has been modified since the given timestamp.

If file exists and it hasn’t been modified since the specified time, an error with kind ErrorKind::ConditionNotMatch will be returned.

use jiff::Timestamp;
use opendal_core::Operator;
let mut metadata = op.read_with("path/to/file").if_modified_since(time).await?;

pub fn if_unmodified_since( self, v: impl Into<Timestamp>, ) -> OperatorFuture<ReadOptions, Buffer, F>

Set if_unmodified_since for this read request.

This feature can be used to check if the file hasn’t been modified since the given timestamp.

If file exists and it has been modified since the specified time, an error with kind ErrorKind::ConditionNotMatch will be returned.

use jiff::Timestamp;
use opendal_core::Operator;
let mut metadata = op
    .read_with("path/to/file")
    .if_unmodified_since(time)
    .await?;

impl<F> OperatorFuture<ReaderOptions, Reader, F>

where F: Future<Output = Result<Reader, Error>>,

pub fn version(self, v: &str) -> OperatorFuture<ReaderOptions, Reader, F>

Set version for this reader.

This feature can be used to retrieve the data of a specified version of the given path.

If the version doesn’t exist, an error with kind ErrorKind::NotFound will be returned.

let mut r = op.reader_with("path/to/file").version(version).await?;

pub fn concurrent( self, concurrent: usize, ) -> OperatorFuture<ReaderOptions, Reader, F>

Set concurrent for the reader.

OpenDAL by default to write file without concurrent. This is not efficient for cases when users read large chunks of data. By setting concurrent, opendal will reading files concurrently on support storage services.

By setting concurrent, opendal will fetch chunks concurrently with the give chunk size.

let r = op.reader_with("path/to/file").concurrent(8).await?;

pub fn chunk( self, chunk_size: usize, ) -> OperatorFuture<ReaderOptions, Reader, F>

OpenDAL will use services’ preferred chunk size by default. Users can set chunk based on their own needs.

This following example will make opendal read data in 4MiB chunks:

let r = op
    .reader_with("path/to/file")
    .chunk(4 * 1024 * 1024)
    .await?;

pub fn gap(self, gap_size: usize) -> OperatorFuture<ReaderOptions, Reader, F>

Controls the optimization strategy for range reads in Reader::fetch.

When performing range reads, if the gap between two requested ranges is smaller than the configured gap size, OpenDAL will merge these ranges into a single read request and discard the unrequested data in between. This helps reduce the number of API calls to remote storage services.

This optimization is particularly useful when performing multiple small range reads that are close to each other, as it reduces the overhead of multiple network requests at the cost of transferring some additional data.

In this example, if two requested ranges are separated by less than 1MiB, they will be merged into a single read request:

let r = op
    .reader_with("path/to/file")
    .chunk(4 * 1024 * 1024)
    .gap(1024 * 1024) // 1MiB gap
    .await?;

pub fn if_match(self, etag: &str) -> OperatorFuture<ReaderOptions, Reader, F>

Set if-match for this read request.

This feature can be used to check if the file’s ETag matches the given ETag.

If file exists and it’s etag doesn’t match, an error with kind ErrorKind::ConditionNotMatch will be returned.

use opendal_core::Operator;
let mut r = op.reader_with("path/to/file").if_match(etag).await?;

pub fn if_none_match( self, etag: &str, ) -> OperatorFuture<ReaderOptions, Reader, F>

Set if-none-match for this read request.

This feature can be used to check if the file’s ETag doesn’t match the given ETag.

If file exists and it’s etag match, an error with kind ErrorKind::ConditionNotMatch will be returned.

use opendal_core::Operator;
let mut r = op.reader_with("path/to/file").if_none_match(etag).await?;

pub fn if_modified_since( self, v: impl Into<Timestamp>, ) -> OperatorFuture<ReaderOptions, Reader, F>

Set if-modified-since for this read request.

This feature can be used to check if the file has been modified since the given timestamp.

If file exists and it hasn’t been modified since the specified time, an error with kind ErrorKind::ConditionNotMatch will be returned.

use jiff::Timestamp;
use opendal_core::Operator;
let mut r = op
    .reader_with("path/to/file")
    .if_modified_since(time)
    .await?;

pub fn if_unmodified_since( self, v: impl Into<Timestamp>, ) -> OperatorFuture<ReaderOptions, Reader, F>

Set if-unmodified-since for this read request.

This feature can be used to check if the file hasn’t been modified since the given timestamp.

If file exists and it has been modified since the specified time, an error with kind ErrorKind::ConditionNotMatch will be returned.

use jiff::Timestamp;
use opendal_core::Operator;
let mut r = op
    .reader_with("path/to/file")
    .if_unmodified_since(time)
    .await?;

impl<F> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

where F: Future<Output = Result<Metadata, Error>>,

pub fn append( self, v: bool, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets append mode for this write request.

Refer to options::WriteOptions::append for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .append(true)
    .await?;

pub fn chunk( self, v: usize, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets chunk size for buffered writes.

Refer to options::WriteOptions::chunk for more details.

Example

use bytes::Bytes;

// Set 8MiB chunk size - data will be sent in one API call at close
let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .chunk(8 * 1024 * 1024)
    .await?;

pub fn concurrent( self, v: usize, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets concurrent write operations for this writer.

Refer to options::WriteOptions::concurrent for more details.

Example

use bytes::Bytes;

// Enable concurrent writes with 8 parallel operations at 128B chunk.
let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .chunk(128)
    .concurrent(8)
    .await?;

pub fn cache_control( self, v: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets Cache-Control header for this write operation.

Refer to options::WriteOptions::cache_control for more details.

Example

use bytes::Bytes;

// Cache content for 7 days (604800 seconds)
let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .cache_control("max-age=604800")
    .await?;

pub fn content_type( self, v: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets Content-Type header for this write operation.

Refer to options::WriteOptions::content_type for more details.

Example

use bytes::Bytes;

// Set content type for plain text file
let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .content_type("text/plain")
    .await?;

pub fn content_disposition( self, v: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets Content-Disposition header for this write request.

Refer to options::WriteOptions::content_disposition for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .content_disposition("attachment; filename=\"filename.jpg\"")
    .await?;

pub fn content_encoding( self, v: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets Content-Encoding header for this write request.

Refer to options::WriteOptions::content_encoding for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .content_encoding("gzip")
    .await?;

pub fn if_match( self, s: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets If-Match header for this write request.

Refer to options::WriteOptions::if_match for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .if_match("\"686897696a7c876b7e\"")
    .await?;

pub fn if_none_match( self, s: &str, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets If-None-Match header for this write request.

Refer to options::WriteOptions::if_none_match for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .if_none_match("\"686897696a7c876b7e\"")
    .await?;

pub fn if_not_exists( self, b: bool, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets the condition that write operation will succeed only if target does not exist.

Refer to options::WriteOptions::if_not_exists for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .if_not_exists(true)
    .await?;

pub fn user_metadata( self, data: impl IntoIterator<Item = (String, String)>, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Sets user metadata for this write request.

Refer to options::WriteOptions::user_metadata for more details.

Example

use bytes::Bytes;

let _ = op
    .write_with("path/to/file", vec![0; 4096])
    .user_metadata([
        ("language".to_string(), "rust".to_string()),
        ("author".to_string(), "OpenDAL".to_string()),
    ])
    .await?;

impl<F> OperatorFuture<WriteOptions, Writer, F>

where F: Future<Output = Result<Writer, Error>>,

pub fn append(self, v: bool) -> OperatorFuture<WriteOptions, Writer, F>

Sets append mode for this write request.

Refer to options::WriteOptions::append for more details.

Example

use bytes::Bytes;

let mut w = op.writer_with("path/to/file").append(true).await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn chunk(self, v: usize) -> OperatorFuture<WriteOptions, Writer, F>

Sets chunk size for buffered writes.

Refer to options::WriteOptions::chunk for more details.

Example

use bytes::Bytes;

// Set 8MiB chunk size - data will be sent in one API call at close
let mut w = op
    .writer_with("path/to/file")
    .chunk(8 * 1024 * 1024)
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn concurrent(self, v: usize) -> OperatorFuture<WriteOptions, Writer, F>

Sets concurrent write operations for this writer.

Refer to options::WriteOptions::concurrent for more details.

Example

use bytes::Bytes;

// Enable concurrent writes with 8 parallel operations
let mut w = op.writer_with("path/to/file").concurrent(8).await?;

// First write starts immediately
w.write(vec![0; 4096]).await?;

// Second write runs concurrently with first
w.write(vec![1; 4096]).await?;

// Ensures all writes complete successfully and in order
w.close().await?;

pub fn cache_control(self, v: &str) -> OperatorFuture<WriteOptions, Writer, F>

Sets Cache-Control header for this write operation.

Refer to options::WriteOptions::cache_control for more details.

Example

use bytes::Bytes;

// Cache content for 7 days (604800 seconds)
let mut w = op
    .writer_with("path/to/file")
    .cache_control("max-age=604800")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn content_type(self, v: &str) -> OperatorFuture<WriteOptions, Writer, F>

Sets Content-Type header for this write operation.

Refer to options::WriteOptions::content_type for more details.

Example

use bytes::Bytes;

// Set content type for plain text file
let mut w = op
    .writer_with("path/to/file")
    .content_type("text/plain")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn content_disposition( self, v: &str, ) -> OperatorFuture<WriteOptions, Writer, F>

Sets Content-Disposition header for this write request.

Refer to options::WriteOptions::content_disposition for more details.

Example

use bytes::Bytes;

let mut w = op
    .writer_with("path/to/file")
    .content_disposition("attachment; filename=\"filename.jpg\"")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn content_encoding( self, v: &str, ) -> OperatorFuture<WriteOptions, Writer, F>

Sets Content-Encoding header for this write request.

Refer to options::WriteOptions::content_encoding for more details.

Example

use bytes::Bytes;

let mut w = op
    .writer_with("path/to/file")
    .content_encoding("gzip")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn if_match(self, s: &str) -> OperatorFuture<WriteOptions, Writer, F>

Sets If-Match header for this write request.

Refer to options::WriteOptions::if_match for more details.

Behavior

• If supported, the write operation will only succeed if the target’s ETag matches the specified value
• The value should be a valid ETag string
• Common values include:
  • A specific ETag value like "686897696a7c876b7e"
  • * - Matches any existing resource
• If not supported, the value will be ignored

This operation provides conditional write functionality based on ETag matching, helping prevent unintended overwrites in concurrent scenarios.

Example

use bytes::Bytes;

let mut w = op
    .writer_with("path/to/file")
    .if_match("\"686897696a7c876b7e\"")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn if_none_match(self, s: &str) -> OperatorFuture<WriteOptions, Writer, F>

Sets If-None-Match header for this write request.

Refer to options::WriteOptions::if_none_match for more details.

Example

use bytes::Bytes;

let mut w = op
    .writer_with("path/to/file")
    .if_none_match("\"686897696a7c876b7e\"")
    .await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn if_not_exists(self, b: bool) -> OperatorFuture<WriteOptions, Writer, F>

Sets the condition that write operation will succeed only if target does not exist.

Refer to options::WriteOptions::if_not_exists for more details.

Example

use bytes::Bytes;

let mut w = op.writer_with("path/to/file").if_not_exists(true).await?;
w.write(vec![0; 4096]).await?;
w.write(vec![1; 4096]).await?;
w.close().await?;

pub fn user_metadata( self, data: impl IntoIterator<Item = (String, String)>, ) -> OperatorFuture<WriteOptions, Writer, F>

Sets user metadata for this write request.

Refer to options::WriteOptions::user_metadata for more details.

Example

use bytes::Bytes;

let mut w = op
    .writer_with("path/to/file")
    .user_metadata([
        ("content-type".to_string(), "text/plain".to_string()),
        ("author".to_string(), "OpenDAL".to_string()),
    ])
    .await?;
w.write(vec![0; 4096]).await?;
w.close().await?;

impl<F> OperatorFuture<DeleteOptions, (), F>

where F: Future<Output = Result<(), Error>>,

pub fn version(self, v: &str) -> OperatorFuture<DeleteOptions, (), F>

Change the version of this delete operation.

pub fn recursive(self, recursive: bool) -> OperatorFuture<DeleteOptions, (), F>

Enable recursive deletion.

impl<F> OperatorFuture<ListOptions, Vec<Entry>, F>

where F: Future<Output = Result<Vec<Entry>, Error>>,

pub fn limit(self, v: usize) -> OperatorFuture<ListOptions, Vec<Entry>, F>

The limit passed to underlying service to specify the max results that could return per-request.

Users could use this to control the memory usage of list operation.

pub fn start_after(self, v: &str) -> OperatorFuture<ListOptions, Vec<Entry>, F>

The start_after passes to underlying service to specify the specified key to start listing from.

pub fn recursive(self, v: bool) -> OperatorFuture<ListOptions, Vec<Entry>, F>

The recursive is used to control whether the list operation is recursive.

• If false, list operation will only list the entries under the given path.
• If true, list operation will list all entries that starts with given path.

Default to false.

pub fn versions(self, v: bool) -> OperatorFuture<ListOptions, Vec<Entry>, F>

Controls whether the list operation should return file versions.

This function allows you to specify if the list operation, when executed, should include information about different versions of files, if versioning is supported and enabled.

If true, subsequent list operations will include version information for each file. If false, version information will be omitted from the list results.

Default to false

pub fn deleted(self, v: bool) -> OperatorFuture<ListOptions, Vec<Entry>, F>

Controls whether the list operation should include deleted files (or versions).

This function allows you to specify if the list operation, when executed, should include entries for files or versions that have been marked as deleted. This is particularly relevant in object storage systems that support soft deletion or versioning.

If true, subsequent list operations will include deleted files or versions. If false, deleted files or versions will be excluded from the list results.

impl<F> OperatorFuture<ListOptions, Lister, F>

where F: Future<Output = Result<Lister, Error>>,

pub fn limit(self, v: usize) -> OperatorFuture<ListOptions, Lister, F>

The limit passed to underlying service to specify the max results that could return per-request.

Users could use this to control the memory usage of list operation.

pub fn start_after(self, v: &str) -> OperatorFuture<ListOptions, Lister, F>

The start_after passes to underlying service to specify the specified key to start listing from.

pub fn recursive(self, v: bool) -> OperatorFuture<ListOptions, Lister, F>

The recursive is used to control whether the list operation is recursive.

• If false, list operation will only list the entries under the given path.
• If true, list operation will list all entries that starts with given path.

Default to false.

pub fn versions(self, v: bool) -> OperatorFuture<ListOptions, Lister, F>

Controls whether the list operation should return file versions.

This function allows you to specify if the list operation, when executed, should include information about different versions of files, if versioning is supported and enabled.

If true, subsequent list operations will include version information for each file. If false, version information will be omitted from the list results.

Default to false

pub fn deleted(self, v: bool) -> OperatorFuture<ListOptions, Lister, F>

Controls whether the list operation should include deleted files (or versions).

This function allows you to specify if the list operation, when executed, should include entries for files or versions that have been marked as deleted. This is particularly relevant in object storage systems that support soft deletion or versioning.

If true, subsequent list operations will include deleted files or versions. If false, deleted files or versions will be excluded from the list results.

impl<F> OperatorFuture<(CopyOptions, String), (), F>

where F: Future<Output = Result<(), Error>>,

pub fn if_not_exists( self, v: bool, ) -> OperatorFuture<(CopyOptions, String), (), F>

Sets the condition that copy operation will succeed only if target does not exist.

Refer to options::CopyOptions::if_not_exists for more details.

Example

let _ = op
    .copy_with("source/path", "target/path")
    .if_not_exists(true)
    .await?;

Trait Implementations

impl<I, O, F> IntoFuture for OperatorFuture<I, O, F>

where F: Future<Output = Result<O, Error>>,

type Output = Result<O, Error>

The output that the future will produce on completion.

type IntoFuture = F

Which kind of future are we turning this into?

fn into_future(self) -> <OperatorFuture<I, O, F> as IntoFuture>::IntoFuture

Creates a future from a value.