nyquest 0.4.0

truly platform-native HTTP client library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Blocking client support.
//!
//! The blocking client will block the current thread to execute.
//!

use std::borrow::Cow;

#[cfg(feature = "blocking-stream")]
use nyquest_interface::blocking::{BoxedStream, SizedBodyStream, UnsizedBodyStream};

pub(crate) mod client;
#[cfg(feature = "blocking-stream")]
mod read_stream;
mod response;

#[cfg(not(feature = "blocking-stream"))]
type BoxedStream = std::convert::Infallible;

/// The Request Body type for blocking requests.
pub type Body = crate::body::Body<BoxedStream>;
/// The Request type for blocking requests.
pub type Request = crate::Request<BoxedStream>;
/// The multipart form part type for blocking requests.
#[cfg(feature = "multipart")]
pub type Part = crate::body::Part<BoxedStream>;
/// The multipart form part body type for blocking requests.
#[cfg(feature = "multipart")]
pub type PartBody = crate::body::PartBody<BoxedStream>;
#[cfg(feature = "blocking-stream")]
pub use read_stream::ReadStream;
pub use response::Response;

#[cfg(feature = "blocking-stream")]
use crate::body::private::{IntoSizedStream, IntoUnsizedStream};

/// Shortcut method to quickly make a `GET` request.
///
/// See also the methods on the [`Response`] type.
///
/// **Note**: This function creates a new internal [`BlockingClient`] on each call, and so should
/// not be used if making many requests. Create a [`BlockingClient`] instead.
///
/// [`BlockingClient`]: crate::BlockingClient
pub fn get(uri: impl Into<Cow<'static, str>>) -> crate::Result<Response> {
    let client = crate::client::ClientBuilder::default().build_blocking()?;
    client.request(Request::get(uri))
}

#[cfg(feature = "blocking-stream")]
impl<S: SizedBodyStream> IntoSizedStream<BoxedStream> for S {
    fn into_stream(self, size: u64) -> BoxedStream {
        BoxedStream::Sized {
            stream: Box::new(self),
            content_length: size,
        }
    }
}

#[cfg(feature = "blocking-stream")]
impl<S: UnsizedBodyStream> IntoUnsizedStream<BoxedStream> for S {
    fn into_stream(self) -> BoxedStream {
        BoxedStream::Unsized {
            stream: Box::new(self),
        }
    }
}