Struct qiniu_upload_manager::PartSize

    pub fn as_u64(&self) -> u64 {
        self.as_non_zero_u64().get()
    }
}

impl Default for PartSize {
    #[inline]
    fn default() -> Self {
        Self(
            #[allow(unsafe_code)]
            unsafe {
                NonZeroU64::new_unchecked(1 << 22)
            },
        )
    }
}

impl From<NonZeroU64> for PartSize {
    #[inline]
    fn from(size: NonZeroU64) -> Self {
        Self(size)
    }
}

impl From<PartSize> for NonZeroU64 {
    #[inline]
    fn from(size: PartSize) -> Self {
        size.as_non_zero_u64()
    }

More examples

Hide additional examples

src/data_partition_provider/limited.rs (line 63)

    fn part_size(&self) -> PartSize {
        let base_partition = self.base.part_size().as_non_zero_u64();
        base_partition.clamp(self.min, self.max).into()
    }

src/data_partition_provider/multiply.rs (line 52)

    fn part_size(&self) -> PartSize {
        let base_partition = self.base.part_size().as_non_zero_u64();
        let multiply = self.multiply.get();
        let partition = base_partition.max(self.multiply).get() / multiply * multiply;
        NonZeroU64::new(partition).unwrap().into()
    }

source

pub fn as_u64(&self) -> u64

获取并发数

Examples found in repository ?

src/data_partition_provider/mod.rs (line 85)

84
85
86

    fn from(size: PartSize) -> Self {
        size.as_u64()
    }

More examples

Hide additional examples

src/resumable_policy/multiple_partitions.rs (line 83)

82
83
84

    fn threshold(&self) -> u64 {
        self.base_partition_provider.part_size().as_u64() * self.multiply.get()
    }

src/data_source/seekable.rs (line 44)

    fn slice(&self, size: PartSize) -> IoResult<Option<DataSourceReader>> {
        let mut cur = self.current.lock().unwrap();
        if cur.offset < self.size {
            let size = size.as_u64();
            let source_reader = DataSourceReader::seekable(
                cur.part_number,
                self.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)
        }
    }

src/data_source/unseekable.rs (line 55)

    fn slice(&self, size: PartSize) -> IoResult<Option<DataSourceReader>> {
        let mut buf = Vec::new();
        let guard = &mut self.0.lock().unwrap();
        let have_read = (&mut guard.reader).take(size.as_u64()).read_to_end(&mut buf)?;
        if have_read > 0 {
            let source_reader = DataSourceReader::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)
        }
    }

    #[inline]
    fn reset(&self) -> IoResult<()> {
        Err(unsupported_reset_error())
    }

    #[inline]
    fn source_key(&self) -> IoResult<Option<SourceKey<A>>> {
        Ok(self.0.lock().unwrap().source_key.to_owned())
    }

    #[inline]
    fn total_size(&self) -> IoResult<Option<u64>> {
        Ok(None)
    }
}

impl<R: Read + Debug + Send + Sync + 'static, A: Digest> Debug for UnseekableDataSourceInner<R, A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("UnseekableDataSourceInner")
            .field("reader", &self.reader)
            .field("current_offset", &self.current_offset)
            .field("current_part_number", &self.current_part_number)
            .field("source_key", &self.source_key)
            .finish()
    }
}

#[cfg(feature = "async")]
mod async_unseekable {
    use super::{
        super::{AsyncDataSource, AsyncDataSourceReader},
        *,
    };
    use futures::{
        future::{self, BoxFuture},
        lock::Mutex,
        AsyncRead, AsyncReadExt,
    };

    /// 不可寻址的异步数据源
    ///
    /// 基于一个不可寻址的异步阅读器实现了异步数据源接口
    pub struct AsyncUnseekableDataSource<R: AsyncRead + Debug + Unpin + Send + Sync + 'static + ?Sized, A: Digest = Sha1>(
        Arc<Mutex<AsyncUnseekableDataSourceInner<R, A>>>,
    );

    impl<R: AsyncRead + Debug + Unpin + Send + Sync + 'static, A: Digest> Debug for AsyncUnseekableDataSource<R, A> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_tuple("AsyncUnseekableDataSource").field(&self.0).finish()
        }
    }

    impl<R: AsyncRead + Debug + Unpin + Send + Sync + 'static, A: Digest> Clone for AsyncUnseekableDataSource<R, A> {
        #[inline]
        fn clone(&self) -> Self {
            Self(self.0.clone())
        }
    }

    struct AsyncUnseekableDataSourceInner<R: AsyncRead + Debug + Unpin + Send + Sync + 'static + ?Sized, A: Digest> {
        current_offset: u64,
        current_part_number: NonZeroUsize,
        source_key: Option<SourceKey<A>>,
        reader: R,
    }

    impl<R: AsyncRead + Debug + Unpin + Send + Sync + 'static, A: Digest> AsyncUnseekableDataSource<R, A> {
        /// 创建不可寻址的异步数据源
        pub fn new(reader: R) -> Self {
            Self(Arc::new(Mutex::new(AsyncUnseekableDataSourceInner {
                reader,
                current_offset: 0,
                current_part_number: first_part_number(),
                source_key: None,
            })))
        }
    }

    impl<R: AsyncRead + Debug + Unpin + Send + Sync + 'static, A: Digest> AsyncDataSource<A>
        for AsyncUnseekableDataSource<R, A>
    {
        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)
                }
            })
        }

src/data_source/file.rs (line 196)

        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,
                }
            })
        }