boluo_core/request.rs
1//! HTTP 请求。
2
3use std::convert::TryFrom;
4
5use http::header::{HeaderMap, HeaderName, HeaderValue};
6use http::method::Method;
7use http::version::Version;
8use http::{Extensions, Result, Uri};
9use sync_wrapper::SyncWrapper;
10
11use crate::body::Body;
12
13/// HTTP 请求。
14///
15/// HTTP 请求由头部和可选的主体组成。主体是泛型的，允许任意类型来表示 HTTP 请求的主体。
16#[derive(Default)]
17pub struct Request<T = Body> {
18 head: RequestParts,
19 body: SyncWrapper<T>,
20}
21
22/// HTTP 请求的头部。
23///
24/// HTTP 请求的头部由方法、URI、版本、一组标头和扩展组成。
25#[derive(Default, Clone)]
26pub struct RequestParts {
27 /// HTTP 请求的方法。
28 pub method: Method,
29 /// HTTP 请求的 URI。
30 pub uri: Uri,
31 /// HTTP 请求的版本。
32 pub version: Version,
33 /// HTTP 请求的标头集。
34 pub headers: HeaderMap<HeaderValue>,
35 /// HTTP 请求的扩展。
36 pub extensions: Extensions,
37}
38
39/// HTTP 请求的构建器。
40#[derive(Debug)]
41pub struct RequestBuilder {
42 inner: Result<Request<()>>,
43}
44
45impl Request<()> {
46 /// 创建新的构建器以构建请求。
47 ///
48 /// # 例子
49 ///
50 /// ```
51 /// use boluo_core::request::Request;
52 ///
53 /// let request = Request::builder()
54 /// .method("GET")
55 /// .uri("https://www.rust-lang.org/")
56 /// .header("X-Custom-Foo", "Bar")
57 /// .body(())
58 /// .unwrap();
59 /// ```
60 #[inline]
61 pub fn builder() -> RequestBuilder {
62 RequestBuilder::new()
63 }
64}
65
66impl<T> Request<T> {
67 /// 使用给定的主体创建一个空白的请求。
68 ///
69 /// 此请求的头部将被设置为默认值。
70 ///
71 /// # 例子
72 ///
73 /// ```
74 /// use boluo_core::http::Method;
75 /// use boluo_core::request::Request;
76 ///
77 /// let mut request = Request::new("hello world");
78 ///
79 /// assert_eq!(*request.method(), Method::GET);
80 /// assert_eq!(*request.body_mut(), "hello world");
81 /// ```
82 #[inline]
83 pub fn new(body: T) -> Request<T> {
84 Request {
85 head: RequestParts::new(),
86 body: SyncWrapper::new(body),
87 }
88 }
89
90 /// 使用给定的头部和主体创建请求。
91 ///
92 /// # 例子
93 ///
94 /// ```
95 /// use boluo_core::http::Method;
96 /// use boluo_core::request::Request;
97 ///
98 /// let request = Request::new("hello world");
99 /// let (mut parts, body) = request.into_inner();
100 ///
101 /// parts.method = Method::POST;
102 /// let mut request = Request::from_parts(parts, body);
103 ///
104 /// assert_eq!(request.method(), Method::POST);
105 /// assert_eq!(*request.body_mut(), "hello world");
106 /// ```
107 #[inline]
108 pub fn from_parts(parts: RequestParts, body: T) -> Request<T> {
109 Request {
110 head: parts,
111 body: SyncWrapper::new(body),
112 }
113 }
114
115 /// 获取请求的 HTTP 方法的引用。
116 ///
117 /// # 例子
118 ///
119 /// ```
120 /// use boluo_core::http::Method;
121 /// use boluo_core::request::Request;
122 ///
123 /// let request: Request<()> = Request::default();
124 ///
125 /// assert_eq!(*request.method(), Method::GET);
126 /// ```
127 #[inline]
128 pub fn method(&self) -> &Method {
129 &self.head.method
130 }
131
132 /// 获取请求的 HTTP 方法的可变引用。
133 ///
134 /// # 例子
135 ///
136 /// ```
137 /// use boluo_core::http::Method;
138 /// use boluo_core::request::Request;
139 ///
140 /// let mut request: Request<()> = Request::default();
141 /// *request.method_mut() = Method::PUT;
142 ///
143 /// assert_eq!(*request.method(), Method::PUT);
144 /// ```
145 #[inline]
146 pub fn method_mut(&mut self) -> &mut Method {
147 &mut self.head.method
148 }
149
150 /// 获取请求的 URI 的引用。
151 ///
152 /// # 例子
153 ///
154 /// ```
155 /// use boluo_core::request::Request;
156 ///
157 /// let request: Request<()> = Request::default();
158 ///
159 /// assert_eq!(*request.uri(), "/");
160 /// ```
161 #[inline]
162 pub fn uri(&self) -> &Uri {
163 &self.head.uri
164 }
165
166 /// 获取请求的 URI 的可变引用。
167 ///
168 /// # 例子
169 ///
170 /// ```
171 /// use boluo_core::request::Request;
172 ///
173 /// let mut request: Request<()> = Request::default();
174 /// *request.uri_mut() = "/hello".parse().unwrap();
175 ///
176 /// assert_eq!(*request.uri(), "/hello");
177 /// ```
178 #[inline]
179 pub fn uri_mut(&mut self) -> &mut Uri {
180 &mut self.head.uri
181 }
182
183 /// 获取请求的 HTTP 版本。
184 ///
185 /// # 例子
186 ///
187 /// ```
188 /// use boluo_core::http::Version;
189 /// use boluo_core::request::Request;
190 ///
191 /// let request: Request<()> = Request::default();
192 ///
193 /// assert_eq!(request.version(), Version::HTTP_11);
194 /// ```
195 #[inline]
196 pub fn version(&self) -> Version {
197 self.head.version
198 }
199
200 /// 获取请求的 HTTP 版本的可变引用。
201 ///
202 /// # 例子
203 ///
204 /// ```
205 /// use boluo_core::http::Version;
206 /// use boluo_core::request::Request;
207 ///
208 /// let mut request: Request<()> = Request::default();
209 /// *request.version_mut() = Version::HTTP_2;
210 ///
211 /// assert_eq!(request.version(), Version::HTTP_2);
212 /// ```
213 #[inline]
214 pub fn version_mut(&mut self) -> &mut Version {
215 &mut self.head.version
216 }
217
218 /// 获取请求的标头集的引用。
219 ///
220 /// # 例子
221 ///
222 /// ```
223 /// use boluo_core::request::Request;
224 ///
225 /// let request: Request<()> = Request::default();
226 ///
227 /// assert!(request.headers().is_empty());
228 /// ```
229 #[inline]
230 pub fn headers(&self) -> &HeaderMap<HeaderValue> {
231 &self.head.headers
232 }
233
234 /// 获取请求的标头集的可变引用。
235 ///
236 /// # 例子
237 ///
238 /// ```
239 /// use boluo_core::http::header::*;
240 /// use boluo_core::request::Request;
241 ///
242 /// let mut request: Request<()> = Request::default();
243 /// request.headers_mut().insert(HOST, HeaderValue::from_static("world"));
244 ///
245 /// assert!(!request.headers().is_empty());
246 /// ```
247 #[inline]
248 pub fn headers_mut(&mut self) -> &mut HeaderMap<HeaderValue> {
249 &mut self.head.headers
250 }
251
252 /// 获取请求的扩展的引用。
253 ///
254 /// # 例子
255 ///
256 /// ```
257 /// use boluo_core::request::Request;
258 ///
259 /// let request: Request<()> = Request::default();
260 ///
261 /// assert!(request.extensions().get::<i32>().is_none());
262 /// ```
263 #[inline]
264 pub fn extensions(&self) -> &Extensions {
265 &self.head.extensions
266 }
267
268 /// 获取请求的扩展的可变引用。
269 ///
270 /// # 例子
271 ///
272 /// ```
273 /// use boluo_core::request::Request;
274 ///
275 /// let mut request: Request<()> = Request::default();
276 /// request.extensions_mut().insert("hello");
277 ///
278 /// assert_eq!(request.extensions().get(), Some(&"hello"));
279 /// ```
280 #[inline]
281 pub fn extensions_mut(&mut self) -> &mut Extensions {
282 &mut self.head.extensions
283 }
284
285 /// 获取请求的主体的可变引用。
286 ///
287 /// # 例子
288 ///
289 /// ```
290 /// use boluo_core::request::Request;
291 ///
292 /// let mut request: Request<String> = Request::default();
293 /// request.body_mut().push_str("hello world");
294 ///
295 /// assert!(!request.body_mut().is_empty());
296 /// ```
297 #[inline]
298 pub fn body_mut(&mut self) -> &mut T {
299 self.body.get_mut()
300 }
301
302 /// 消耗请求，返回请求的主体。
303 ///
304 /// # 例子
305 ///
306 /// ```
307 /// use boluo_core::request::Request;
308 ///
309 /// let request = Request::new(10);
310 /// let body = request.into_body();
311 ///
312 /// assert_eq!(body, 10);
313 /// ```
314 #[inline]
315 pub fn into_body(self) -> T {
316 self.body.into_inner()
317 }
318
319 /// 获取请求的头部的引用。
320 ///
321 /// # 例子
322 ///
323 /// ```
324 /// use boluo_core::http::Method;
325 /// use boluo_core::request::Request;
326 ///
327 /// let request: Request<()> = Request::default();
328 ///
329 /// assert_eq!(request.parts().method, Method::GET);
330 /// ```
331 #[inline]
332 pub fn parts(&self) -> &RequestParts {
333 &self.head
334 }
335
336 /// 获取请求的头部的可变引用。
337 ///
338 /// # 例子
339 ///
340 /// ```
341 /// use boluo_core::http::Method;
342 /// use boluo_core::request::Request;
343 ///
344 /// let mut request: Request<()> = Request::default();
345 /// request.parts_mut().method = Method::PUT;
346 ///
347 /// assert_eq!(*request.method(), Method::PUT);
348 /// ```
349 #[inline]
350 pub fn parts_mut(&mut self) -> &mut RequestParts {
351 &mut self.head
352 }
353
354 /// 消耗请求，返回请求的头部。
355 ///
356 /// # 例子
357 ///
358 /// ```
359 /// use boluo_core::http::Method;
360 /// use boluo_core::request::Request;
361 ///
362 /// let request = Request::new(());
363 /// let parts = request.into_parts();
364 ///
365 /// assert_eq!(parts.method, Method::GET);
366 /// ```
367 #[inline]
368 pub fn into_parts(self) -> RequestParts {
369 self.head
370 }
371
372 /// 消耗请求，返回请求的头部和主体。
373 ///
374 /// # 例子
375 ///
376 /// ```
377 /// use boluo_core::http::Method;
378 /// use boluo_core::request::Request;
379 ///
380 /// let request = Request::new(());
381 /// let (parts, body) = request.into_inner();
382 ///
383 /// assert_eq!(parts.method, Method::GET);
384 /// assert_eq!(body, ());
385 /// ```
386 #[inline]
387 pub fn into_inner(self) -> (RequestParts, T) {
388 (self.head, self.body.into_inner())
389 }
390
391 /// 消耗请求，返回带有给定主体的新请求，其主体为传入闭包的返回值。
392 ///
393 /// # 例子
394 ///
395 /// ```
396 /// use boluo_core::request::Request;
397 ///
398 /// let request = Request::builder().body("some string").unwrap();
399 /// let mut mapped_request: Request<&[u8]> = request.map(|b| {
400 /// assert_eq!(b, "some string");
401 /// b.as_bytes()
402 /// });
403 ///
404 /// assert_eq!(mapped_request.body_mut(), &"some string".as_bytes());
405 /// ```
406 #[inline]
407 pub fn map<F, U>(self, f: F) -> Request<U>
408 where
409 F: FnOnce(T) -> U,
410 {
411 Request {
412 body: SyncWrapper::new(f(self.body.into_inner())),
413 head: self.head,
414 }
415 }
416}
417
418impl<T: std::fmt::Debug> std::fmt::Debug for Request<T> {
419 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
420 f.debug_struct("Request")
421 .field("method", self.method())
422 .field("uri", self.uri())
423 .field("version", &self.version())
424 .field("headers", self.headers())
425 .field("body", &std::any::type_name::<T>())
426 .finish()
427 }
428}
429
430impl RequestParts {
431 fn new() -> RequestParts {
432 RequestParts {
433 method: Method::default(),
434 uri: Uri::default(),
435 version: Version::default(),
436 headers: HeaderMap::default(),
437 extensions: Extensions::default(),
438 }
439 }
440}
441
442impl std::fmt::Debug for RequestParts {
443 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
444 f.debug_struct("RequestParts")
445 .field("method", &self.method)
446 .field("uri", &self.uri)
447 .field("version", &self.version)
448 .field("headers", &self.headers)
449 .finish()
450 }
451}
452
453impl RequestBuilder {
454 /// 创建构建器的默认实例以构建请求。
455 ///
456 /// # 例子
457 ///
458 /// ```
459 /// use boluo_core::request::RequestBuilder;
460 ///
461 /// let req = RequestBuilder::new()
462 /// .method("POST")
463 /// .body(())
464 /// .unwrap();
465 /// ```
466 #[inline]
467 pub fn new() -> RequestBuilder {
468 RequestBuilder::default()
469 }
470
471 /// 设置请求的 HTTP 方法。
472 ///
473 /// 默认情况下，这是 `GET`。
474 ///
475 /// # 例子
476 ///
477 /// ```
478 /// use boluo_core::request::Request;
479 ///
480 /// let req = Request::builder()
481 /// .method("POST")
482 /// .body(())
483 /// .unwrap();
484 /// ```
485 pub fn method<T>(self, method: T) -> RequestBuilder
486 where
487 Method: TryFrom<T>,
488 <Method as TryFrom<T>>::Error: Into<http::Error>,
489 {
490 self.and_then(move |mut req| {
491 let method = TryFrom::try_from(method).map_err(Into::into)?;
492 req.head.method = method;
493 Ok(req)
494 })
495 }
496
497 /// 获取请求的 HTTP 方法的引用。
498 ///
499 /// 默认情况下，这是 `GET`。如果构建器有错误，则返回 [`None`]。
500 ///
501 /// # 例子
502 ///
503 /// ```
504 /// use boluo_core::http::Method;
505 /// use boluo_core::request::Request;
506 ///
507 /// let mut req = Request::builder();
508 /// assert_eq!(req.method_ref(), Some(&Method::GET));
509 ///
510 /// req = req.method("POST");
511 /// assert_eq!(req.method_ref(), Some(&Method::POST));
512 /// ```
513 pub fn method_ref(&self) -> Option<&Method> {
514 self.inner.as_ref().ok().map(|req| &req.head.method)
515 }
516
517 /// 获取请求的 HTTP 方法的可变引用。
518 ///
519 /// 默认情况下，这是 `GET`。如果构建器有错误，则返回 [`None`]。
520 ///
521 /// # 例子
522 ///
523 /// ```
524 /// use boluo_core::http::Method;
525 /// use boluo_core::request::Request;
526 ///
527 /// let mut req = Request::builder();
528 /// assert_eq!(req.method_ref(), Some(&Method::GET));
529 ///
530 /// *req.method_mut().unwrap() = Method::POST;
531 /// assert_eq!(req.method_ref(), Some(&Method::POST));
532 /// ```
533 pub fn method_mut(&mut self) -> Option<&mut Method> {
534 self.inner.as_mut().ok().map(|req| &mut req.head.method)
535 }
536
537 /// 设置请求的 URI。
538 ///
539 /// 默认情况下，这是 `/`。
540 ///
541 /// # 例子
542 ///
543 /// ```
544 /// use boluo_core::request::Request;
545 ///
546 /// let req = Request::builder()
547 /// .uri("https://www.rust-lang.org/")
548 /// .body(())
549 /// .unwrap();
550 /// ```
551 pub fn uri<T>(self, uri: T) -> RequestBuilder
552 where
553 Uri: TryFrom<T>,
554 <Uri as TryFrom<T>>::Error: Into<http::Error>,
555 {
556 self.and_then(move |mut req| {
557 let uri = TryFrom::try_from(uri).map_err(Into::into)?;
558 req.head.uri = uri;
559 Ok(req)
560 })
561 }
562
563 /// 获取请求的 URI 的引用。
564 ///
565 /// 默认情况下，这是 `/`。如果构建器有错误，则返回 [`None`]。
566 ///
567 /// # 例子
568 ///
569 /// ```
570 /// use boluo_core::request::Request;
571 ///
572 /// let mut req = Request::builder();
573 /// assert_eq!(req.uri_ref().unwrap(), "/");
574 ///
575 /// req = req.uri("https://www.rust-lang.org/");
576 /// assert_eq!(req.uri_ref().unwrap(), "https://www.rust-lang.org/");
577 /// ```
578 pub fn uri_ref(&self) -> Option<&Uri> {
579 self.inner.as_ref().ok().map(|req| &req.head.uri)
580 }
581
582 /// 获取请求的 URI 的可变引用。
583 ///
584 /// 默认情况下，这是 `/`。如果构建器有错误，则返回 [`None`]。
585 ///
586 /// # 例子
587 ///
588 /// ```
589 /// use boluo_core::request::Request;
590 ///
591 /// let mut req = Request::builder();
592 /// assert_eq!(req.uri_ref().unwrap(), "/");
593 ///
594 /// *req.uri_mut().unwrap() = "https://www.rust-lang.org/".parse().unwrap();
595 /// assert_eq!(req.uri_ref().unwrap(), "https://www.rust-lang.org/");
596 /// ```
597 pub fn uri_mut(&mut self) -> Option<&mut Uri> {
598 self.inner.as_mut().ok().map(|req| &mut req.head.uri)
599 }
600
601 /// 设置请求的 HTTP 版本。
602 ///
603 /// 默认情况下，这是 `HTTP/1.1`。
604 ///
605 /// # 例子
606 ///
607 /// ```
608 /// use boluo_core::http::Version;
609 /// use boluo_core::request::Request;
610 ///
611 /// let req = Request::builder()
612 /// .version(Version::HTTP_2)
613 /// .body(())
614 /// .unwrap();
615 /// ```
616 pub fn version(self, version: Version) -> RequestBuilder {
617 self.and_then(move |mut req| {
618 req.head.version = version;
619 Ok(req)
620 })
621 }
622
623 /// 获取请求的 HTTP 版本的引用。
624 ///
625 /// 默认情况下，这是 `HTTP/1.1`。如果构建器有错误，则返回 [`None`]。
626 ///
627 /// # 例子
628 ///
629 /// ```
630 /// use boluo_core::http::Version;
631 /// use boluo_core::request::Request;
632 ///
633 /// let mut req = Request::builder();
634 /// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_11);
635 ///
636 /// req = req.version(Version::HTTP_2);
637 /// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_2);
638 /// ```
639 pub fn version_ref(&self) -> Option<&Version> {
640 self.inner.as_ref().ok().map(|req| &req.head.version)
641 }
642
643 /// 获取请求的 HTTP 版本的可变引用。
644 ///
645 /// 默认情况下，这是 `HTTP/1.1`。如果构建器有错误，则返回 [`None`]。
646 ///
647 /// # 例子
648 ///
649 /// ```
650 /// use boluo_core::http::Version;
651 /// use boluo_core::request::Request;
652 ///
653 /// let mut req = Request::builder();
654 /// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_11);
655 ///
656 /// *req.version_mut().unwrap() = Version::HTTP_2;
657 /// assert_eq!(req.version_ref().unwrap(), &Version::HTTP_2);
658 /// ```
659 pub fn version_mut(&mut self) -> Option<&mut Version> {
660 self.inner.as_mut().ok().map(|req| &mut req.head.version)
661 }
662
663 /// 将标头追加到请求中。
664 ///
665 /// 此函数将提供的键值对追加到请求内部的 [`HeaderMap`] 中。本质上，
666 /// 这相当于调用 [`HeaderMap::append`]。
667 ///
668 /// # 例子
669 ///
670 /// ```
671 /// use boluo_core::request::Request;
672 ///
673 /// let req = Request::builder()
674 /// .header("Accept", "text/html")
675 /// .header("X-Custom-Foo", "bar")
676 /// .body(())
677 /// .unwrap();
678 /// ```
679 pub fn header<K, V>(self, key: K, value: V) -> RequestBuilder
680 where
681 HeaderName: TryFrom<K>,
682 <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
683 HeaderValue: TryFrom<V>,
684 <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
685 {
686 self.and_then(move |mut req| {
687 let name = <HeaderName as TryFrom<K>>::try_from(key).map_err(Into::into)?;
688 let value = <HeaderValue as TryFrom<V>>::try_from(value).map_err(Into::into)?;
689 req.head.headers.append(name, value);
690 Ok(req)
691 })
692 }
693
694 /// 获取请求的标头集的引用。
695 ///
696 /// 如果构建器有错误，则返回 [`None`]。
697 ///
698 /// # 例子
699 ///
700 /// ```
701 /// use boluo_core::request::Request;
702 ///
703 /// let req = Request::builder()
704 /// .header("Accept", "text/html")
705 /// .header("X-Custom-Foo", "bar");
706 ///
707 /// let headers = req.headers_ref().unwrap();
708 ///
709 /// assert_eq!(headers["Accept"], "text/html");
710 /// assert_eq!(headers["X-Custom-Foo"], "bar");
711 /// ```
712 pub fn headers_ref(&self) -> Option<&HeaderMap<HeaderValue>> {
713 self.inner.as_ref().ok().map(|req| &req.head.headers)
714 }
715
716 /// 获取请求的标头集的可变引用。
717 ///
718 /// 如果构建器有错误，则返回 [`None`]。
719 ///
720 /// # 例子
721 ///
722 /// ```
723 /// use boluo_core::http::HeaderValue;
724 /// use boluo_core::request::Request;
725 ///
726 /// let mut req = Request::builder();
727 ///
728 /// let headers = req.headers_mut().unwrap();
729 /// headers.insert("Accept", HeaderValue::from_static("text/html"));
730 /// headers.insert("X-Custom-Foo", HeaderValue::from_static("bar"));
731 ///
732 /// let headers = req.headers_ref().unwrap();
733 /// assert_eq!(headers["Accept"], "text/html");
734 /// assert_eq!(headers["X-Custom-Foo"], "bar");
735 /// ```
736 pub fn headers_mut(&mut self) -> Option<&mut HeaderMap<HeaderValue>> {
737 self.inner.as_mut().ok().map(|req| &mut req.head.headers)
738 }
739
740 /// 将一个类型添加到请求的扩展中。
741 ///
742 /// # 例子
743 ///
744 /// ```
745 /// use boluo_core::request::Request;
746 ///
747 /// let req = Request::builder()
748 /// .extension("My Extension")
749 /// .body(())
750 /// .unwrap();
751 ///
752 /// assert_eq!(req.extensions().get::<&'static str>(),
753 /// Some(&"My Extension"));
754 /// ```
755 pub fn extension<T>(self, extension: T) -> RequestBuilder
756 where
757 T: Clone + Send + Sync + 'static,
758 {
759 self.and_then(move |mut req| {
760 req.head.extensions.insert(extension);
761 Ok(req)
762 })
763 }
764
765 /// 获取请求的扩展的引用。
766 ///
767 /// 如果构建器有错误，则返回 [`None`]。
768 ///
769 /// # 例子
770 ///
771 /// ```
772 /// use boluo_core::request::Request;
773 ///
774 /// let req = Request::builder().extension("My Extension").extension(5u32);
775 /// let extensions = req.extensions_ref().unwrap();
776 ///
777 /// assert_eq!(extensions.get::<&'static str>(), Some(&"My Extension"));
778 /// assert_eq!(extensions.get::<u32>(), Some(&5u32));
779 /// ```
780 pub fn extensions_ref(&self) -> Option<&Extensions> {
781 self.inner.as_ref().ok().map(|req| &req.head.extensions)
782 }
783
784 /// 获取请求的扩展的可变引用。
785 ///
786 /// 如果构建器有错误，则返回 [`None`]。
787 ///
788 /// # 例子
789 ///
790 /// ```
791 /// use boluo_core::request::Request;
792 ///
793 /// let mut req = Request::builder().extension("My Extension");
794 /// let mut extensions = req.extensions_mut().unwrap();
795 /// assert_eq!(extensions.get::<&'static str>(), Some(&"My Extension"));
796 ///
797 /// extensions.insert(5u32);
798 /// assert_eq!(extensions.get::<u32>(), Some(&5u32));
799 /// ```
800 pub fn extensions_mut(&mut self) -> Option<&mut Extensions> {
801 self.inner.as_mut().ok().map(|req| &mut req.head.extensions)
802 }
803
804 /// 消耗构建器，使用给定的主体构建请求。
805 ///
806 /// # 错误
807 ///
808 /// 如果之前配置的任意一个参数发生错误，则在调用此函数时将返回错误。
809 ///
810 /// # 例子
811 ///
812 /// ```
813 /// use boluo_core::request::Request;
814 ///
815 /// let request = Request::builder()
816 /// .body(())
817 /// .unwrap();
818 /// ```
819 pub fn body<T>(self, body: T) -> Result<Request<T>> {
820 self.inner.map(move |req| req.map(|_| body))
821 }
822
823 fn and_then<F>(self, func: F) -> Self
824 where
825 F: FnOnce(Request<()>) -> Result<Request<()>>,
826 {
827 RequestBuilder {
828 inner: self.inner.and_then(func),
829 }
830 }
831}
832
833impl Default for RequestBuilder {
834 #[inline]
835 fn default() -> RequestBuilder {
836 RequestBuilder {
837 inner: Ok(Request::new(())),
838 }
839 }
840}