Struct qiniu_http_client::Part

pub struct Part<B> { /* private fields */ }

Multipart 表单组件

Implementations

impl<'a> Part<SyncPartBody<'a>>

pub fn text(value: impl Into<Cow<'a, str>>) -> Self

设置阻塞 Multipart 的请求体为字符串

pub fn bytes(value: impl Into<Cow<'a, [u8]>>) -> Self

设置阻塞 Multipart 的请求体为内存数据

pub fn stream(value: impl Read + 'a) -> Self

设置阻塞 Multipart 的请求体为输入流

Examples found in repository

src/client/request/multipart.rs (line 294)

        pub fn file_path<S: AsRef<OsStr> + ?Sized>(path: &S) -> IoResult<Self> {
            let path = Path::new(path);
            let file = File::open(path)?;
            let mut metadata = PartMetadata::default().mime(mime_guess::from_path(path).first_or_octet_stream());
            if let Some(file_name) = path.file_name() {
                let file_name = match file_name.to_string_lossy() {
                    Cow::Borrowed(str) => FileName::from(str),
                    Cow::Owned(string) => FileName::from(string),
                };
                metadata = metadata.file_name(file_name);
            }
            Ok(SyncPart::stream(file).metadata(metadata))
        }

pub fn file_path<S: AsRef<OsStr> + ?Sized>(path: &S) -> IoResult<Self>

设置阻塞 Multipart 的请求体为文件

impl<'a> Part<AsyncPartBody<'a>>

pub fn text(value: impl Into<Cow<'a, str>>) -> Self

设置异步 Multipart 的请求体为字符串

pub fn bytes(value: impl Into<Cow<'a, [u8]>>) -> Self

设置异步 Multipart 的请求体为内存数据

pub fn stream(value: impl AsyncRead + Send + Unpin + 'a) -> Self

设置异步 Multipart 的请求体为异步输入流

Examples found in repository

src/client/request/multipart.rs (line 431)

        pub async fn file_path<S: AsRef<OsStr> + ?Sized>(path: &S) -> IoResult<AsyncPart<'a>> {
            let path = Path::new(path);
            let file = File::open(&path).await?;
            let mut metadata = PartMetadata::default().mime(mime_guess::from_path(path).first_or_octet_stream());
            if let Some(file_name) = path.file_name() {
                let file_name = match file_name.to_string_lossy() {
                    Cow::Borrowed(str) => FileName::from(str),
                    Cow::Owned(string) => FileName::from(string),
                };
                metadata = metadata.file_name(file_name);
            }
            Ok(AsyncPart::stream(file).metadata(metadata))
        }

pub async fn file_path<S: AsRef<OsStr> + ?Sized>(
    path: &S
) -> IoResult<AsyncPart<'a>>

设置异步 Multipart 的请求体为文件

impl<B> Part<B>

pub fn metadata(self, metadata: PartMetadata) -> Self

设置 Multipart 表单组件的元信息

Examples found in repository

src/client/request/multipart.rs (line 294)

        pub fn file_path<S: AsRef<OsStr> + ?Sized>(path: &S) -> IoResult<Self> {
            let path = Path::new(path);
            let file = File::open(path)?;
            let mut metadata = PartMetadata::default().mime(mime_guess::from_path(path).first_or_octet_stream());
            if let Some(file_name) = path.file_name() {
                let file_name = match file_name.to_string_lossy() {
                    Cow::Borrowed(str) => FileName::from(str),
                    Cow::Owned(string) => FileName::from(string),
                };
                metadata = metadata.file_name(file_name);
            }
            Ok(SyncPart::stream(file).metadata(metadata))
        }
    }

    /// 阻塞 Multipart
    pub type SyncMultipart<'a> = Multipart<SyncPart<'a>>;

    impl<'a> SyncMultipart<'a> {
        pub(in super::super) fn into_read(mut self) -> Box<dyn Read + 'a> {
            if self.fields.is_empty() {
                return Box::new(Cursor::new([]));
            }

            let (name, part) = self.fields.pop_front().unwrap();
            let chain = Box::new(self.part_stream(&name, part)) as Box<dyn Read + 'a>;
            let fields = take(&mut self.fields);
            Box::new(
                fields
                    .into_iter()
                    .fold(chain, |readable, (name, part)| {
                        Box::new(readable.chain(self.part_stream(&name, part))) as Box<dyn Read + 'a>
                    })
                    .chain(Cursor::new(b"--"))
                    .chain(Cursor::new(self.boundary.to_owned()))
                    .chain(Cursor::new(b"--\r\n")),
            )
        }

        fn part_stream(&self, name: &str, part: SyncPart<'a>) -> impl Read + 'a {
            Cursor::new(b"--")
                .chain(Cursor::new(self.boundary.to_owned()))
                .chain(Cursor::new(b"\r\n"))
                .chain(Cursor::new(encode_headers(name, &part.meta)))
                .chain(Cursor::new(b"\r\n\r\n"))
                .chain(part.body)
                .chain(Cursor::new(b"\r\n"))
        }
    }

    impl Read for SyncPartBody<'_> {
        #[inline]
        fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
            match &mut self.0 {
                SyncPartBodyInner::Bytes(bytes) => bytes.read(buf),
                SyncPartBodyInner::Stream(stream) => stream.read(buf),
            }
        }
    }
}
pub use sync_part::{SyncMultipart, SyncPart, SyncPartBody};

#[cfg(feature = "async")]
mod async_part {
    use super::*;
    use async_std::{fs::File, path::Path};
    use futures::io::{AsyncRead, AsyncReadExt, Cursor};
    use std::{
        fmt::{self, Debug},
        io::Result as IoResult,
        mem::take,
        pin::Pin,
        task::{Context, Poll},
    };

    type AsyncStream<'a> = Box<dyn AsyncRead + Send + Unpin + 'a>;

    enum AsyncPartBodyInner<'a> {
        Bytes(Cursor<Cow<'a, [u8]>>),
        Stream(AsyncStream<'a>),
    }

    impl Debug for AsyncPartBodyInner<'_> {
        #[inline]
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            match self {
                Self::Bytes(bytes) => f.debug_tuple("Bytes").field(bytes).finish(),
                Self::Stream(_) => f.debug_tuple("Stream").finish(),
            }
        }
    }

    /// 异步 Multipart 表单组件请求体
    #[derive(Debug)]
    #[cfg_attr(feature = "docs", doc(cfg(feature = "async")))]
    pub struct AsyncPartBody<'a>(AsyncPartBodyInner<'a>);

    /// 异步 Multipart 表单组件
    #[cfg_attr(feature = "docs", doc(cfg(feature = "async")))]
    pub type AsyncPart<'a> = Part<AsyncPartBody<'a>>;

    impl<'a> AsyncPart<'a> {
        /// 设置异步 Multipart 的请求体为字符串
        #[inline]
        #[must_use]
        pub fn text(value: impl Into<Cow<'a, str>>) -> Self {
            let bytes = match value.into() {
                Cow::Borrowed(slice) => Cow::Borrowed(slice.as_bytes()),
                Cow::Owned(string) => Cow::Owned(string.into_bytes()),
            };
            Self {
                body: AsyncPartBody(AsyncPartBodyInner::Bytes(Cursor::new(bytes))),
                meta: Default::default(),
            }
        }

        /// 设置异步 Multipart 的请求体为内存数据
        #[inline]
        #[must_use]
        pub fn bytes(value: impl Into<Cow<'a, [u8]>>) -> Self {
            Self {
                body: AsyncPartBody(AsyncPartBodyInner::Bytes(Cursor::new(value.into()))),
                meta: Default::default(),
            }
        }

        /// 设置异步 Multipart 的请求体为异步输入流
        #[inline]
        #[must_use]
        pub fn stream(value: impl AsyncRead + Send + Unpin + 'a) -> Self {
            Self {
                body: AsyncPartBody(AsyncPartBodyInner::Stream(Box::new(value))),
                meta: Default::default(),
            }
        }

        /// 设置异步 Multipart 的请求体为文件
        pub async fn file_path<S: AsRef<OsStr> + ?Sized>(path: &S) -> IoResult<AsyncPart<'a>> {
            let path = Path::new(path);
            let file = File::open(&path).await?;
            let mut metadata = PartMetadata::default().mime(mime_guess::from_path(path).first_or_octet_stream());
            if let Some(file_name) = path.file_name() {
                let file_name = match file_name.to_string_lossy() {
                    Cow::Borrowed(str) => FileName::from(str),
                    Cow::Owned(string) => FileName::from(string),
                };
                metadata = metadata.file_name(file_name);
            }
            Ok(AsyncPart::stream(file).metadata(metadata))
        }

Trait Implementations

impl<B: Debug> Debug for Part<B>

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

Formats the value using the given formatter.