rama-core 0.2.0-alpha.11

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
84
85
86
87
88
89
90
91
92
93
94
95

use crate::{Context, context::Extensions};

use super::Matcher;

/// Extension to apply matcher operations to an [`Iterator`] of [`Matcher`]s.
pub trait IteratorMatcherExt<'a, M, State, Request>: Iterator<Item = &'a M> + 'a
where
    M: Matcher<State, Request>,
{
    /// Matches in case all [`Matcher`] elements match for the given `Request`
    /// within the specified [`crate::Context`].
    fn matches_and(
        self,
        ext: Option<&mut Extensions>,
        ctx: &Context<State>,
        request: &Request,
    ) -> bool;

    /// Matches in case any of the [`Matcher`] elements match for the given `Request`
    /// within the specified [`crate::Context`].
    fn matches_or(
        self,
        ext: Option<&mut Extensions>,
        ctx: &Context<State>,
        request: &Request,
    ) -> bool;
}

impl<'a, I, M, State, Request> IteratorMatcherExt<'a, M, State, Request> for I
where
    I: Iterator<Item = &'a M> + 'a,
    M: Matcher<State, Request>,
{
    fn matches_and(
        self,
        ext: Option<&mut Extensions>,
        ctx: &Context<State>,
        request: &Request,
    ) -> bool {
        match ext {
            None => {
                for matcher in self {
                    if !matcher.matches(None, ctx, request) {
                        return false;
                    }
                }
                true
            }
            Some(ext) => {
                let mut inner_ext = Extensions::new();
                for matcher in self {
                    if !matcher.matches(Some(&mut inner_ext), ctx, request) {
                        return false;
                    }
                }
                ext.extend(inner_ext);
                true
            }
        }
    }

    fn matches_or(
        self,
        ext: Option<&mut Extensions>,
        ctx: &Context<State>,
        request: &Request,
    ) -> bool {
        let mut it = self.peekable();
        if it.peek().is_none() {
            return true;
        }

        match ext {
            None => {
                for matcher in it {
                    if matcher.matches(None, ctx, request) {
                        return true;
                    }
                }
                false
            }
            Some(ext) => {
                let mut inner_ext = Extensions::new();
                for matcher in it {
                    if matcher.matches(Some(&mut inner_ext), ctx, request) {
                        ext.extend(inner_ext);
                        return true;
                    }
                    inner_ext.clear();
                }
                false
            }
        }
    }
}