Struct Router 

pub struct Router { /* private fields */ }

Implementations

impl Router

pub fn get<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Examples found in repository

examples/02_controller.rs (line 11)

pub fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().get("/", index);

    println!("\r\n\r\nRunning Server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/01_hello_world.rs (lines 6-8)

pub fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().get("/", async |_req, res| {
        res.html("<h1>Hello World</h1>")
    });

    println!("\r\n\r\nRunning Server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/09_session.rs (line 33)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", home_view);
        router.get("login", login);
        router.get("logout", logout);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/11_multipart.rs (line 36)

fn main() {
    let server = server("127.0.0.1", 9999)
        .storage("default", LocalStorage::new("storage"));

    server.router().group("/", |router| {
        router.get("/", home);
        router.post("upload", upload);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/15_hook.rs (lines 34-37)

pub fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().get("/", async |_req, res| {
        println!("CONTROLLER");
        res.html("<h1>Hello controller</h1>")
    });

    server.hook(CustomHook::new());

    println!("\r\n\r\nRunning Server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/10_cookie.rs (line 33)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", home_view);
        router.get("cookie", cookie);
        router.delete("cookie/remove", remove_cookie);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

Additional examples can be found in:

• examples/08_middleware.rs
• examples/03_routing.rs
• examples/06_env.rs
• examples/07_assets.rs
• examples/05_views.rs
• examples/04_advanced_routing.rs
• examples/14_mail.rs
• examples/16_logger.rs

pub fn post<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Examples found in repository

examples/11_multipart.rs (line 37)

fn main() {
    let server = server("127.0.0.1", 9999)
        .storage("default", LocalStorage::new("storage"));

    server.router().group("/", |router| {
        router.get("/", home);
        router.post("upload", upload);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/12_validation.rs (line 43)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.post("register", register).middleware(register_form);
        router.post("documents", upload).middleware(upload_documents_form);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/04_advanced_routing.rs (line 52)

fn main() {
    let server = server("127.0.0.1", 9999);
    
    server.router().group("/", |router| {
        router.group("users", |router| {
            router.get("/", index);
            router.post("/", store);
            router.group("{user}", |router| {
                router.get("/", view);
                router.patch("/", update);
                router.delete("/", destroy);
            });
        });
    });

    server.router().not_found(not_found);

    server.error(error);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

pub fn put<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub fn patch<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Examples found in repository

examples/04_advanced_routing.rs (line 55)

fn main() {
    let server = server("127.0.0.1", 9999);
    
    server.router().group("/", |router| {
        router.group("users", |router| {
            router.get("/", index);
            router.post("/", store);
            router.group("{user}", |router| {
                router.get("/", view);
                router.patch("/", update);
                router.delete("/", destroy);
            });
        });
    });

    server.router().not_found(not_found);

    server.error(error);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

pub fn delete<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Examples found in repository

examples/10_cookie.rs (line 35)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", home_view);
        router.get("cookie", cookie);
        router.delete("cookie/remove", remove_cookie);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/04_advanced_routing.rs (line 56)

fn main() {
    let server = server("127.0.0.1", 9999);
    
    server.router().group("/", |router| {
        router.group("users", |router| {
            router.get("/", index);
            router.post("/", store);
            router.group("{user}", |router| {
                router.get("/", view);
                router.patch("/", update);
                router.delete("/", destroy);
            });
        });
    });

    server.router().not_found(not_found);

    server.error(error);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

pub fn copy<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub fn head<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub fn options<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub fn route<C, Fut>( &mut self, method: impl Into<String>, path: impl Into<String>, callback: C, ) -> &mut Route<HttpHandler>

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

pub fn not_found<C, Fut>(&mut self, callback: C)

where C: Fn(Request, Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Examples found in repository

examples/03_routing.rs (line 26)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", async |_req, res| {
            return res.html("<h1>Hello World!!!</h1>")
        });
    });

    server.router().not_found(not_found);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/04_advanced_routing.rs (line 61)

fn main() {
    let server = server("127.0.0.1", 9999);
    
    server.router().group("/", |router| {
        router.group("users", |router| {
            router.get("/", index);
            router.post("/", store);
            router.group("{user}", |router| {
                router.get("/", view);
                router.patch("/", update);
                router.delete("/", destroy);
            });
        });
    });

    server.router().not_found(not_found);

    server.error(error);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

pub fn ws<C, Fut>( &mut self, path: impl Into<String>, callback: C, ) -> &mut Route<WebsocketHandler>

where C: Fn(Request, Websocket) -> Fut + Send + Sync + 'static, Fut: Future<Output = Websocket> + Send + 'static,

Examples found in repository

examples/13_websocket.rs (lines 7-21)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("", |router| {
        router.ws("/", async |_req, ws| -> Websocket {
            ws.on(async |event, writer| {
                match event {
                    flyer::websocket::Event::Ready() => todo!(),
                    flyer::websocket::Event::Text(bytes) => {
                        println!("Received: {}", String::from_utf8_lossy(&bytes));
                        writer.write("Hello from WebSocket!".into()).unwrap();
                    },
                    flyer::websocket::Event::Binary(_bytes) => todo!(),
                    flyer::websocket::Event::Ping(_bytes) => todo!(),
                    flyer::websocket::Event::Pong(_bytes) => todo!(),
                    flyer::websocket::Event::Close(_reason) => todo!(),
                }
            })
        });
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

pub fn group(&mut self, path: &str, group: Group) -> &mut GroupRouter

Examples found in repository

examples/09_session.rs (lines 32-36)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", home_view);
        router.get("login", login);
        router.get("logout", logout);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/11_multipart.rs (lines 35-38)

fn main() {
    let server = server("127.0.0.1", 9999)
        .storage("default", LocalStorage::new("storage"));

    server.router().group("/", |router| {
        router.get("/", home);
        router.post("upload", upload);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/10_cookie.rs (lines 32-36)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", home_view);
        router.get("cookie", cookie);
        router.delete("cookie/remove", remove_cookie);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/08_middleware.rs (lines 28-32)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("api", |router| {
        router.get("/", async |_req, res| {
            return res.html("<h1>Authorized Access</h1>");
        });
    }).middleware(auth);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/12_validation.rs (lines 42-45)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.post("register", register).middleware(register_form);
        router.post("documents", upload).middleware(upload_documents_form);
    });

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

examples/03_routing.rs (lines 20-24)

fn main() {
    let server = server("127.0.0.1", 9999);

    server.router().group("/", |router| {
        router.get("/", async |_req, res| {
            return res.html("<h1>Hello World!!!</h1>")
        });
    });

    server.router().not_found(not_found);

    print!("\r\n\r\nRunning server: {}\r\n\r\n", server.address());

    server.listen();
}

Additional examples can be found in:

• examples/06_env.rs
• examples/04_advanced_routing.rs
• examples/16_logger.rs
• examples/13_websocket.rs

pub fn subdomain( &mut self, subdomain: impl Into<String>, group: Group, ) -> &mut GroupRouter

pub fn middleware<C, Fut>(&mut self, callback: C) -> &mut Self

where C: for<'a> Fn(Request, Response, Next) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Trait Implementations

impl Clone for Router

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<&Router> for Router

fn from(value: &Router) -> Self

Converts to this type from the input type.