rama-core 0.3.0

rama service core code, used by rama and service authors
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

use super::Matcher;
use crate::extensions::Extensions;
use rama_utils::macros::all_the_tuples_no_last_special_case;

/// A matcher that matches if any of the inner matchers match.
#[derive(Debug, Clone)]
pub struct Or<T>(T);

impl<T> Or<T> {
    /// Create a new `Or` matcher.
    pub const fn new(inner: T) -> Self {
        Self(inner)
    }
}

macro_rules! impl_or_matches {
    ($($ty:ident),+ $(,)?) => {
        fn matches(&self, ext: Option<&Extensions>, req: &Request) -> bool {
            let ($($ty),+,) = &self.0;
            match ext {
                Some(ext) => {
                    $(
                        let mut inner_ext = Extensions::new();
                        if $ty.matches(Some(&mut inner_ext), req) {
                            ext.extend(&inner_ext);
                            return true;
                        }
                    )+
                    false
                }
                None => {
                    $(
                        if $ty.matches(None, req) {
                            return true;
                        }
                    )+
                    false
                }
            }
        }
    };
}

macro_rules! impl_or {
    ($T1:ident,$T2:ident,$T3:ident,$T4:ident,$T5:ident,$T6:ident,$T7:ident,$T8:ident,$T9:ident,$T10:ident,$T11:ident,$T12:ident $(,)?) => {
        impl<Request, $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11, $T12> Matcher<Request> for Or<($T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11, $T12)>
            where $T1: Matcher<Request>,
                  $T2: Matcher<Request>,
                  $T3: Matcher<Request>,
                  $T4: Matcher<Request>,
                  $T5: Matcher<Request>,
                  $T6: Matcher<Request>,
                  $T7: Matcher<Request>,
                  $T8: Matcher<Request>,
                  $T9: Matcher<Request>,
                  $T10: Matcher<Request>,
                  $T11: Matcher<Request>,
                  $T12: Matcher<Request>,
        {
            impl_or_matches!( $T1, $T2, $T3, $T4, $T5, $T6, $T7, $T8, $T9, $T10, $T11, $T12 );
        }
    };

    ($($ty:ident),+ $(,)?) => {
        impl<Request, $($ty),+> Matcher<Request> for Or<($($ty),+,)>
            where $($ty: Matcher<Request>),+
        {
            impl_or_matches!( $($ty),+ );

            fn or<M>(self, matcher: M) -> impl Matcher<Request>
            where
                Self: Sized,
                M: Matcher<Request>,
            {
                let ($($ty),+,) = self.0;
                let inner = ($($ty,)+ matcher);
                Or::new(inner)
            }
        }
    };
}

all_the_tuples_no_last_special_case!(impl_or);