chuchi 0.1.5

Http async library based on hyper and tokio
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

#[macro_export]
macro_rules! impl_res_extractor {
	($ty:ty) => {
		impl<'a, R> $crate::extractor::Extractor<'a, R> for &'a $ty {
			type Error = std::convert::Infallible;
			type Prepared = ();

			$crate::extractor_validate!(|validate| {
				assert!(
					validate.resources.exists::<$ty>(),
					"Resource {} does not exist",
					stringify!($ty)
				);
			});

			$crate::extractor_prepare!();

			$crate::extractor_extract!(|extract| {
				Ok(extract.resources.get::<$ty>().unwrap())
			});
		}
	};
}

#[macro_export]
macro_rules! impl_req_extractor {
	($ty:ty) => {
		impl<'a> $crate::extractor::Extractor<'a, $ty> for $ty {
			type Error = std::convert::Infallible;
			type Prepared = ();

			$crate::extractor_validate!();

			$crate::extractor_prepare!();

			$crate::extractor_extract!(<$ty> |extract| {
				Ok(extract.request.take().unwrap())
			});
		}
	};
}

#[macro_export]
macro_rules! extractor_validate {
	() => {
		$crate::extractor_validate!(|_validate| {});
	};
	(|$validate:ident| $block:block) => {
		fn validate($validate: $crate::extractor::Validate<'_>) {
			$block
		}
	};
}

#[macro_export]
macro_rules! extractor_prepare {
	() => {
		$crate::extractor_prepare!(|_prepare| { Ok(()) });
	};
	(|$prepare:ident| $block:block) => {
		fn prepare(
			$prepare: $crate::extractor::Prepare<'_>,
		) -> std::pin::Pin<
			std::boxed::Box<
				dyn std::future::Future<
						Output = std::result::Result<
							Self::Prepared,
							Self::Error,
						>,
					> + Send
					+ '_,
			>,
		> {
			Box::pin(async move { $block })
		}
	};
}

#[macro_export]
macro_rules! extractor_extract {
	// () => {
	// 	$crate::extractor_prepare!(|_prepare| { Ok(()) });
	// };
	(|$extract:ident| $block:block) => {
		$crate::extractor_extract!(<R> |$extract| $block);
	};
	(<$r:ty> |$extract:ident| $block:block) => {
		fn extract(
			$extract: $crate::extractor::Extract<'a, '_, Self::Prepared, $r>,
		) -> std::result::Result<Self, Self::Error>
		where
			Self: Sized,
		{
			$block
		}
	};
}