Struct qiniu_upload_manager::AsyncDataSourceReader

pub struct AsyncDataSourceReader { /* private fields */ }

Available on crate feature async only.

异步数据源阅读器

提供异步读取接口

Implementations

impl AsyncDataSourceReader

pub fn seekable(part_number: NonZeroUsize, source: AsyncSeekableSource) -> Self

创建可寻址的异步数据源阅读器

Examples found in repository

src/data_source/file.rs (lines 197-200)

        fn slice(&self, size: PartSize) -> BoxFuture<IoResult<Option<AsyncDataSourceReader>>> {
            Box::pin(async move {
                match self.get_async_seekable_source().await? {
                    AsyncSource::Seekable {
                        source,
                        current,
                        file_size,
                        ..
                    } => {
                        let mut cur = current.lock().await;
                        if cur.offset < *file_size {
                            let size = size.as_u64();
                            let source_reader = AsyncDataSourceReader::seekable(
                                cur.part_number,
                                source.clone_with_new_offset_and_length(cur.offset, size),
                            );
                            cur.offset += size;
                            cur.part_number =
                                NonZeroUsize::new(cur.part_number.get() + 1).expect("Page number is too big");
                            Ok(Some(source_reader))
                        } else {
                            Ok(None)
                        }
                    }
                    AsyncSource::Unseekable(source) => source.slice(size).await,
                }
            })
        }

pub fn unseekable(part_number: NonZeroUsize, data: Vec<u8>, offset: u64) -> Self

创建不可寻址的异步数据源阅读器

Examples found in repository

src/data_source/unseekable.rs (line 155)

        fn slice(&self, size: PartSize) -> BoxFuture<IoResult<Option<AsyncDataSourceReader>>> {
            Box::pin(async move {
                let mut buf = Vec::new();
                let guard = &mut self.0.lock().await;
                let have_read = (&mut guard.reader).take(size.as_u64()).read_to_end(&mut buf).await?;
                if have_read > 0 {
                    let source_reader =
                        AsyncDataSourceReader::unseekable(guard.current_part_number, buf, guard.current_offset);
                    guard.current_offset += have_read as u64;
                    guard.current_part_number =
                        NonZeroUsize::new(guard.current_part_number.get() + 1).expect("Page number is too big");
                    Ok(Some(source_reader))
                } else {
                    Ok(None)
                }
            })
        }

Trait Implementations

impl AsyncRead for AsyncDataSourceReader

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut [u8]
) -> Poll<IoResult<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl AsyncReset for AsyncDataSourceReader

fn reset(&mut self) -> BoxFuture<'_, IoResult<()>>

异步重置输入流

impl Debug for AsyncDataSourceReader

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

Formats the value using the given formatter.