tigon 0.1.0

None
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Copyright 2022 Parthka. All rights reserved. MIT license.

use super::types::{HandFn, Route};
use super::Method;

// router path and handler
#[derive(Clone)]
pub struct Router {
    pub routes: Vec<Route>,
}

impl Router {
    // new router
    pub fn new() -> Self {
        Router { routes: Vec::new() }
    }

    // add route
    pub fn add(&mut self, path: &'static str, method: Method, hand: HandFn) {
        // create new route
        let route = Route {
            path: path.to_string(),
            hand_fn: hand,
            method,
        };

        // push route to routes
        self.routes.push(route);
    }

    pub fn all(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("ALL".as_bytes()).unwrap(), hand);
    }

    pub fn get(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::GET, hand);
    }

    pub fn post(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::POST, hand);
    }

    pub fn put(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::PUT, hand);
    }

    pub fn delete(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::DELETE, hand);
    }

    pub fn patch(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::PATCH, hand);
    }

    pub fn copy(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("COPY".as_bytes()).unwrap(), hand);
    }

    pub fn options(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::OPTIONS, hand);
    }

    pub fn link(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("LINK".as_bytes()).unwrap(), hand);
    }

    pub fn unlink(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("UNLINK".as_bytes()).unwrap(), hand);
    }

    pub fn purge(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("PURGE".as_bytes()).unwrap(), hand);
    }

    pub fn lock(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("LOCK".as_bytes()).unwrap(), hand);
    }

    pub fn unlock(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("UNLOCK".as_bytes()).unwrap(), hand);
    }

    pub fn view(&mut self, path: &'static str, hand: HandFn) {
        self.add(path, Method::from_bytes("VIEW".as_bytes()).unwrap(), hand);
    }

    pub fn propfind(&mut self, path: &'static str, hand: HandFn) {
        self.add(
            path,
            Method::from_bytes("PROPFIND".as_bytes()).unwrap(),
            hand,
        );
    }

    // get route
    pub fn find(&self, path: String, method: Method) -> Option<&Route> {
        for route in self.routes.iter() {
            if route.method.clone().as_str() == "ALL" {
                if route.path == path {
                    return Some(route);
                }
            } else {
                if route.path == path && route.method.clone() == method {
                    return Some(route);
                }
            }
        }

        None
    }
}