oxidy 0.5.0

Fast & Minimum Web Framework for Rust
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

/*
 * Get Callback for Route in Parallel
 */
pub(crate) struct IsFind {
    pub(crate) find: bool,
    pub(crate) param: Vec<(String, String)>,
}

pub(crate) async fn find_callback(path: String, callback_path: String) -> IsFind {
    /*
     * Path Split
     */
    let path_split: Vec<String> = path
        .split('/')
        .filter(|x: &&str| !x.is_empty())
        .map(|x: &str| x.to_owned())
        .collect();
    /*
     * Callback Path Split
     * Dynamic Match
     */
    let callback_path_split: Vec<String> = callback_path
        .split('/')
        .filter(|x: &&str| !x.is_empty())
        .map(|x: &str| x.to_owned())
        .collect();
    /*
     * Check Split Length
     */
    if callback_path_split.len() != path_split.len() {
        return IsFind {
            find: false,
            param: Vec::new(),
        };
    }

    let mut prepare_path: String = String::new();
    let mut param: Vec<(String, String)> = Vec::new();

    callback_path_split
        .into_iter()
        .enumerate()
        .for_each(|(i, callback_path_elm)| {
            let callback_path_char: char = callback_path_elm
                .chars()
                .next()
                .expect("[Error] Fail to convert from path string to path char");
            /*
             * Static
             */
            if callback_path_elm == path_split[i] {
                prepare_path.push_str(&format!("/{}", callback_path_elm));
            }
            /*
             * Dynamic
             */
            else if callback_path_char == ':' {
                prepare_path.push_str(&format!("/{}", callback_path_elm));
                param.push((callback_path_elm.replace(':', ""), path_split[i].to_owned()));
            }
        });
    /*
     * Match current path with prepare path
     */
    if callback_path == prepare_path {
        return IsFind { find: true, param };
    }

    IsFind { find: false, param }
}