Skip to main content

OperatorFuture

opendal::operator_futures

Struct OperatorFuture 

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

Operator produces this future.

The future consumes its inputs when it begins executing.

§NOTES

OpenDAL uses this type as an implementation detail. Users should not use it 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>

Stat only when the file has this exact ETag.

Refer to options::StatOptions::if_match for the full contract.

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

Stat only when the file does not have this ETag.

Refer to options::StatOptions::if_none_match for the full contract.

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

Stat only when the file has this exact version.

Refer to options::StatOptions::if_version_match for the full contract.

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

Stat only when the file does not have this version.

Refer to options::StatOptions::if_version_not_match for the full contract.

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

Stat only when the file was modified after this timestamp.

Refer to options::StatOptions::if_modified_since for the full contract.

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

Stat only when the file was not modified after this timestamp.

Refer to options::StatOptions::if_unmodified_since for the full contract.

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

Stat the given version of the file instead of the current one.

Refer to options::StatOptions::version for the full contract.

§

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>

Make the presigned request stat only when the file has this exact ETag.

Refer to options::StatOptions::if_match for the full contract.

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

Make the presigned request stat only when the file does not have this ETag.

Refer to options::StatOptions::if_none_match for the full contract.

§

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>

Make the presigned request read only when the file has this exact ETag.

Refer to options::ReadOptions::if_match for the full contract.

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

Make the presigned request read only when the file does not have this ETag.

Refer to options::ReadOptions::if_none_match for the full contract.

§

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 Into<BytesRange>, ) -> 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
  • BytesRange::suffix(1024) means read the last min(1024, n) bytes of file
let bs = op.read_with("path/to/file").range(0..1024).await?;

pub fn content_length_hint( self, v: u64, ) -> OperatorFuture<ReadOptions, Buffer, F>

Sets known content length as a hint for this read request.

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

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>

Read the given version of the file instead of the current one.

Refer to options::ReadOptions::version for the full contract.


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

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

Read only when the file has this exact ETag.

Refer to options::ReadOptions::if_match for the full contract.

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>

Read only when the file does not have this ETag.

Refer to options::ReadOptions::if_none_match for the full contract.

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

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

Read only when the file has this exact version.

Refer to options::ReadOptions::if_version_match for the full contract.

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

Read only when the file does not have this version.

Refer to options::ReadOptions::if_version_not_match for the full contract.

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

Read only when the file was modified after this timestamp.

Refer to options::ReadOptions::if_modified_since for the full contract.

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>

Read only when the file was not modified after this timestamp.

Refer to options::ReadOptions::if_unmodified_since for the full contract.

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>

Read the given version of the file instead of the current one.

Refer to options::ReaderOptions::version for the full contract.


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 content_length_hint( self, v: u64, ) -> OperatorFuture<ReaderOptions, Reader, F>

Sets known content length as a hint for this reader.

Refer to options::ReaderOptions::content_length_hint for more details.

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 less than or equal to 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.

Set to 0 to disable merging ranges separated by a gap. Overlapping or adjacent ranges are still merged.

In this example, if two requested ranges are separated by no more than 1 MiB, 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>

Read only when the file has this exact ETag.

Refer to options::ReaderOptions::if_match for the full contract.

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>

Read only when the file does not have this ETag.

Refer to options::ReaderOptions::if_none_match for the full contract.

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

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

Read only when the file has this exact version.

Refer to options::ReaderOptions::if_version_match for the full contract.

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

Read only when the file does not have this version.

Refer to options::ReaderOptions::if_version_not_match for the full contract.

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

Read only when the file was modified after this timestamp.

Refer to options::ReaderOptions::if_modified_since for the full contract.

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>

Read only when the file was not modified after this timestamp.

Refer to options::ReaderOptions::if_unmodified_since for the full contract.

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>

Write only when the file at the write path has this exact ETag.

Refer to options::WriteOptions::if_match for the full contract.

§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>

Write only when the file at the write path does not have this ETag.

Refer to options::WriteOptions::if_none_match for the full contract.

§Example
use bytes::Bytes;

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

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

Write only when the file at the write path has this exact version.

Refer to options::WriteOptions::if_version_match for the full contract.

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

Write only when the file at the write path does not have this version.

Refer to options::WriteOptions::if_version_not_match for the full contract.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<(WriteOptions, Buffer), Metadata, F>

Write only when the file still has the identity recorded in metadata.

Refer to options::WriteOptions::if_not_changed for the full contract.

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

Write only when no file exists at the write path.

Refer to options::WriteOptions::if_not_exists for the full contract.

§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>

Write only when the file at the write path has this exact ETag.

Refer to options::WriteOptions::if_match for the full contract. Depending on the service, the conditional error may surface when creating the writer, while writing, or when closing it.

§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>

Write only when the file at the write path does not have this ETag.

Refer to options::WriteOptions::if_none_match for the full contract.

§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_version_match( self, version: &str, ) -> OperatorFuture<WriteOptions, Writer, F>

Write only when the file at the write path has this exact version.

Refer to options::WriteOptions::if_version_match for the full contract.

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

Write only when the file at the write path does not have this version.

Refer to options::WriteOptions::if_version_not_match for the full contract.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<WriteOptions, Writer, F>

Write only when the file still has the identity recorded in metadata.

Refer to options::WriteOptions::if_not_changed for the full contract.

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

Write only when no file exists at the write path.

Refer to options::WriteOptions::if_not_exists for the full contract.

§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>

Delete the given version of the file instead of the current one.

Refer to options::DeleteOptions::version for the full contract.

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

Enable recursive deletion.

Refer to options::DeleteOptions::recursive for the full contract.

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

Delete only when the file at the delete path has this exact ETag.

Refer to options::DeleteOptions::if_match for the full contract.

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

Delete only when the file at the delete path does not have this ETag.

Refer to options::DeleteOptions::if_none_match for the full contract.

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

Delete only when the file at the delete path has this exact version.

Refer to options::DeleteOptions::if_version_match for the full contract.

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

Delete only when the file at the delete path does not have this version.

Refer to options::DeleteOptions::if_version_not_match for the full contract.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<DeleteOptions, (), F>

Delete only when the file still has the identity recorded in metadata.

Refer to options::DeleteOptions::if_not_changed for the full contract.

§

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<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>
where F: Future<Output = Result<Metadata, Error>>,

pub fn cache_control( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set destination Cache-Control metadata.

pub fn content_type( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set destination Content-Type metadata.

pub fn content_disposition( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set destination Content-Disposition metadata.

pub fn content_encoding( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set destination Content-Encoding metadata.

pub fn user_metadata( self, value: HashMap<String, String>, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set destination user metadata.

pub fn if_not_exists( self, value: bool, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require a missing destination object.

pub fn if_match( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require this destination ETag.

pub fn if_none_match( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require a different destination ETag.

pub fn if_version_match( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require this destination version.

pub fn if_version_not_match( self, value: &str, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require a different destination version.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Require the destination to retain the identity in metadata.

pub fn concurrent( self, value: usize, ) -> OperatorFuture<(ComposeOptions, Vec<(String, ComposeSourceOptions)>), Metadata, F>

Set the maximum number of independent backend tasks.

§

impl<F> OperatorFuture<ComposeOptions, Composer, F>
where F: Future<Output = Result<Composer, Error>>,

pub fn cache_control( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set destination Cache-Control metadata.

pub fn content_type( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set destination Content-Type metadata.

pub fn content_disposition( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set destination Content-Disposition metadata.

pub fn content_encoding( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set destination Content-Encoding metadata.

pub fn user_metadata( self, value: HashMap<String, String>, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set destination user metadata.

pub fn if_not_exists( self, value: bool, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require a missing destination object.

pub fn if_match( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require this destination ETag.

pub fn if_none_match( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require a different destination ETag.

pub fn if_version_match( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require this destination version.

pub fn if_version_not_match( self, value: &str, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require a different destination version.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<ComposeOptions, Composer, F>

Require the destination to retain the identity in metadata.

pub fn concurrent( self, value: usize, ) -> OperatorFuture<ComposeOptions, Composer, F>

Set the maximum number of independent backend tasks.

§

impl<F> OperatorFuture<(CopyOptions, String), Metadata, F>
where F: Future<Output = Result<Metadata, Error>>,

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

Copy only when no file exists at the destination path.

Refer to options::CopyOptions::if_not_exists for the full contract.

§Example

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

pub fn if_match( self, etag: &str, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy only when the destination file has this exact ETag.

Refer to options::CopyOptions::if_match for the full contract.

pub fn if_none_match( self, etag: &str, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy only when the destination file does not have this ETag.

Refer to options::CopyOptions::if_none_match for the full contract.

pub fn if_version_match( self, version: &str, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy only when the destination file has this exact version.

Refer to options::CopyOptions::if_version_match for the full contract.

pub fn if_version_not_match( self, version: &str, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy only when the destination file does not have this version.

Refer to options::CopyOptions::if_version_not_match for the full contract.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy only when the destination file still has the identity recorded in metadata.

Refer to options::CopyOptions::if_not_changed for the full contract.

pub fn source_version( self, version: impl Into<String>, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Copy from this source file version instead of the current one.

Refer to options::CopyOptions::source_version for the full contract.

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

Sets concurrent copy operations for this copy.

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

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

Sets chunk size for segmented copy operations.

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

pub fn source_content_length_hint( self, v: u64, ) -> OperatorFuture<(CopyOptions, String), Metadata, F>

Sets known source content length as a hint for this copy request.

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

§

impl<F> OperatorFuture<(CopyOptions, String), Copier, F>
where F: Future<Output = Result<Copier, Error>>,

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

Copy only when no file exists at the destination path.

Refer to options::CopyOptions::if_not_exists for the full contract.

pub fn if_match( self, etag: &str, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy only when the destination file has this exact ETag.

Refer to options::CopyOptions::if_match for the full contract.

pub fn if_none_match( self, etag: &str, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy only when the destination file does not have this ETag.

Refer to options::CopyOptions::if_none_match for the full contract.

pub fn if_version_match( self, version: &str, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy only when the destination file has this exact version.

Refer to options::CopyOptions::if_version_match for the full contract.

pub fn if_version_not_match( self, version: &str, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy only when the destination file does not have this version.

Refer to options::CopyOptions::if_version_not_match for the full contract.

pub fn if_not_changed( self, metadata: &Metadata, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy only when the destination file still has the identity recorded in metadata.

Refer to options::CopyOptions::if_not_changed for the full contract.

pub fn source_version( self, version: impl Into<String>, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Copy from this source file version instead of the current one.

Refer to options::CopyOptions::source_version for the full contract.

pub fn source_content_length_hint( self, v: u64, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Sets known source content length as a hint for this copier.

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

pub fn concurrent( self, v: usize, ) -> OperatorFuture<(CopyOptions, String), Copier, F>

Sets concurrent copy operations for this copier.

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

pub fn chunk(self, v: usize) -> OperatorFuture<(CopyOptions, String), Copier, F>

Sets chunk size for segmented copy operations.

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

§

impl<F> OperatorFuture<(RenameOptions, String), (), F>
where F: Future<Output = Result<(), Error>>,

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

Rename only when no file exists at the destination path.

Refer to options::RenameOptions::if_not_exists for the full contract.

§Example
use opendal_core::Operator;
use opendal_core::Result;

async fn rename_with_options(op: Operator) -> Result<()> {
    op.rename_with("source/path", "target/path")
        .if_not_exists(true)
        .await?;
    Ok(())
}
§

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

pub fn version( self, version: impl Into<String>, ) -> OperatorFuture<RestoreOptions, (), F>

Restore this historical version as the current version.

Refer to options::RestoreOptions::version for the full contract.

pub fn if_not_exists( self, if_not_exists: bool, ) -> OperatorFuture<RestoreOptions, (), F>

Restore the selected version only when no file currently exists at the restore path.

Refer to options::RestoreOptions::if_not_exists for the full contract.

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. Read more

Auto Trait Implementations§

§

impl<I, O, F> Freeze for OperatorFuture<I, O, F>
where I: Freeze,

§

impl<I, O, F> !RefUnwindSafe for OperatorFuture<I, O, F>

§

impl<I, O, F> Send for OperatorFuture<I, O, F>
where I: Send,

§

impl<I, O, F> Sync for OperatorFuture<I, O, F>
where I: Sync,

§

impl<I, O, F> Unpin for OperatorFuture<I, O, F>
where I: Unpin,

§

impl<I, O, F> UnsafeUnpin for OperatorFuture<I, O, F>
where I: UnsafeUnpin,

§

impl<I, O, F> !UnwindSafe for OperatorFuture<I, O, F>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<U> As for U

§

fn as_<T>(self) -> T
where T: CastFrom<U>,

Casts self to type T. The semantics of numeric casting with the as operator are followed, so <T as As>::as_::<U> can be used in the same way as T as U for numeric conversions. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> DropFlavorWrapper<T> for T

§

type Flavor = MayDrop

The DropFlavor that [wrap]s T into Self
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

§

const WITNESS: W = W::MAKE

A constant of the type witness
§

impl<T> Identity for T
where T: ?Sized,

§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Scope for T

§

fn with<F, R>(self, f: F) -> R
where Self: Sized, F: FnOnce(Self) -> R,

Scoped with ownership.
§

fn with_ref<F, R>(&self, f: F) -> R
where F: FnOnce(&Self) -> R,

Scoped with reference.
§

fn with_mut<F, R>(&mut self, f: F) -> R
where F: FnOnce(&mut Self) -> R,

Scoped with mutable reference.
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

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
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<G1, G2> Within<G2> for G1
where G2: Contains<G1>,

§

fn is_within(&self, b: &G2) -> bool

§

impl<T> AsyncFriendly for T
where T: Send + Sync + 'static,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> Value for T
where T: Send + Sync + 'static,