hpx 2.4.8

High Performance HTTP Client
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use http::Version;

#[cfg(feature = "http1")]
use crate::client::core::http1::Http1Options;
#[cfg(feature = "http2")]
use crate::client::core::http2::Http2Options;
use crate::{client::conn::TcpConnectOptions, proxy::Matcher, tls::TlsOptions};

/// Per-request configuration for proxy, protocol, and transport options.
/// Overrides client defaults for a single request.
#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
#[non_exhaustive]
pub struct RequestOptions {
    proxy_matcher: Option<Matcher>,
    enforced_version: Option<Version>,
    tcp_connect_opts: TcpConnectOptions,
    transport_opts: TransportOptions,
}

/// Transport options for HTTP/1, HTTP/2, and TLS layers.
///
/// This struct allows you to customize protocol-specific and TLS settings
/// for network connections made by the client.
#[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
#[non_exhaustive]
pub struct TransportOptions {
    pub(crate) tls_options: Option<TlsOptions>,
    #[cfg(feature = "http1")]
    pub(crate) http1_options: Option<Http1Options>,
    #[cfg(feature = "http2")]
    pub(crate) http2_options: Option<Http2Options>,
}

// ===== impl RequestOptions =====

impl_request_config_value!(RequestOptions);

// ===== impl TransportOptions =====

impl TransportOptions {
    /// Get the reference to the TLS options.
    #[inline]
    pub fn tls_options(&self) -> Option<&TlsOptions> {
        self.tls_options.as_ref()
    }

    /// Get a mutable reference to the TLS options.
    #[inline]
    pub fn tls_options_mut(&mut self) -> &mut Option<TlsOptions> {
        &mut self.tls_options
    }

    /// Get the reference to the HTTP/1 options.
    #[cfg(feature = "http1")]
    #[inline]
    pub fn http1_options(&self) -> Option<&Http1Options> {
        self.http1_options.as_ref()
    }

    /// Get a mutable reference to the HTTP/1 options.
    #[cfg(feature = "http1")]
    #[inline]
    pub fn http1_options_mut(&mut self) -> &mut Option<Http1Options> {
        &mut self.http1_options
    }

    /// Get the reference to the HTTP/2 options.
    #[cfg(feature = "http2")]
    #[inline]
    pub fn http2_options(&self) -> Option<&Http2Options> {
        self.http2_options.as_ref()
    }

    /// Get a mutable reference to the HTTP/2 options.
    #[cfg(feature = "http2")]
    #[inline]
    pub fn http2_options_mut(&mut self) -> &mut Option<Http2Options> {
        &mut self.http2_options
    }

    /// Apply the transport options for HTTP/1, HTTP/2, and TLS.
    pub(crate) fn apply_transport_options(&mut self, opts: TransportOptions) -> &mut Self {
        if let Some(tls) = opts.tls_options {
            *self.tls_options_mut() = Some(tls);
        }
        #[cfg(feature = "http1")]
        if let Some(http1) = opts.http1_options {
            *self.http1_options_mut() = Some(http1);
        }
        #[cfg(feature = "http2")]
        if let Some(http2) = opts.http2_options {
            *self.http2_options_mut() = Some(http2);
        }
        self
    }
}

// ===== impl RequestOptions =====

impl RequestOptions {
    /// Get a reference to the proxy matcher.
    #[inline]
    pub fn proxy_matcher(&self) -> Option<&Matcher> {
        self.proxy_matcher.as_ref()
    }

    /// Get a mutable reference to the proxy matcher.
    #[inline]
    pub fn proxy_matcher_mut(&mut self) -> &mut Option<Matcher> {
        &mut self.proxy_matcher
    }

    /// Get the enforced HTTP version.
    #[inline]
    pub fn enforced_version(&self) -> Option<Version> {
        self.enforced_version
    }

    /// Get a mutable reference to the enforced HTTP version.
    #[inline]
    pub fn enforced_version_mut(&mut self) -> &mut Option<Version> {
        &mut self.enforced_version
    }

    /// Get a reference to the TCP connection options.
    #[inline]
    pub fn tcp_connect_opts(&self) -> &TcpConnectOptions {
        &self.tcp_connect_opts
    }

    /// Get a mutable reference to the TCP connection options.
    #[inline]
    pub fn tcp_connect_opts_mut(&mut self) -> &mut TcpConnectOptions {
        &mut self.tcp_connect_opts
    }

    /// Get a reference to the transport options.
    #[inline]
    pub fn transport_opts(&self) -> &TransportOptions {
        &self.transport_opts
    }

    /// Get a mutable reference to the transport options.
    #[inline]
    pub fn transport_opts_mut(&mut self) -> &mut TransportOptions {
        &mut self.transport_opts
    }
}