composable-tower-http 0.3.1

Highly customizable http utilities built on top of tower.
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

use std::future::Future;

use http::HeaderMap;

use super::chain::chain_extractor::ChainExtractor;

use super::chain::lite::{AsyncChainLite, ChainLite};
use super::{
    and::AndExtractor,
    any::Any,
    convert::{AsyncConvert, Convert},
    map::{AsyncMap, Map, MapError},
    optional::Optional,
    or::OrExtractor,
};

pub trait Extractor {
    type Extracted: Clone + Send + Sync;

    type Error;

    fn extract(
        &self,
        headers: &HeaderMap,
    ) -> impl Future<Output = Result<Self::Extracted, Self::Error>> + Send;

    fn extracted_type_name(&self) -> &'static str {
        std::any::type_name::<Self::Extracted>()
    }
}

pub trait ExtractorExt: Sized + Extractor {
    fn map<Fn>(self, map: Fn) -> Map<Self, Fn> {
        Map::new(self, map)
    }

    fn async_map<Fn>(self, map: Fn) -> AsyncMap<Self, Fn> {
        AsyncMap::new(self, map)
    }

    fn map_err<Fn>(self, map_err: Fn) -> MapError<Self, Fn> {
        MapError::new(self, map_err)
    }

    fn convert<Fn>(self, convert: Fn) -> Convert<Self, Fn> {
        Convert::new(self, convert)
    }

    fn async_convert<Fn>(self, convert: Fn) -> AsyncConvert<Self, Fn> {
        AsyncConvert::new(self, convert)
    }

    fn chain<C>(self, chain: C) -> ChainExtractor<Self, C> {
        ChainExtractor::new(self, chain)
    }

    fn chain_lite<Fn>(self, chain: Fn) -> ChainLite<Self, Fn> {
        ChainLite::new(self, chain)
    }

    fn async_chain_lite<Fn>(self, chain: Fn) -> AsyncChainLite<Self, Fn> {
        AsyncChainLite::new(self, chain)
    }

    fn optional(self) -> Optional<Self> {
        Optional::new(self)
    }

    fn any<Ex>(self, other: Ex) -> Any<Self, Ex> {
        Any::new(self, other)
    }

    fn or<Ex>(self, other: Ex) -> OrExtractor<Self, Ex> {
        OrExtractor::new(self, other)
    }

    fn and<Ex>(self, other: Ex) -> AndExtractor<Self, Ex> {
        AndExtractor::new(self, other)
    }
}

impl<T> ExtractorExt for T where T: Sized + Extractor {}