Struct RouterBuilder

Source

pub struct RouterBuilder<T: Clone> { /* private fields */ }

Expand description

Router builder

Implementations§

Source §

impl<T: Clone> RouterBuilder<T>

Source

pub fn with(ctx: T) -> Self

Create new router with context

Examples found in repository ?

examples/small-router-simple.rs (line 30)

29fn main() {
30    let router = RouterBuilder::with(())
31        .get("/", home)
32        .get("/hello/:name", hello)
33        .fallback(not_found)
34        .build();
35
36    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
37        .unwrap_or_else(|_| panic!("Can't bind to port"));
38    small_http::serve(listener, move |req| router.handle(req));
39}

More examples

Hide additional examples

examples/small-router-context.rs (line 37)

33fn main() {
34    let ctx = Context {
35        data: "Data".to_string(),
36    };
37    let router = RouterBuilder::with(ctx)
38        .get("/", home)
39        .get("/about", about)
40        .fallback(not_found)
41        .build();
42
43    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
44        .unwrap_or_else(|_| panic!("Can't bind to port"));
45    small_http::serve(listener, move |req| router.handle(req));
46}

examples/small-router-layers.rs (line 55)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}

Source

pub fn pre_layer(self, layer: fn(&Request, &mut T) -> Option<Response>) -> Self

Add pre layer

Examples found in repository ?

examples/small-router-layers.rs (line 56)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}

Source

pub fn post_layer( self, layer: fn(&Request, &mut T, Response) -> Response, ) -> Self

Add post layer

Examples found in repository ?

examples/small-router-layers.rs (line 57)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}

Source

pub fn route( self, methods: &[Method], route: String, handler: fn(&Request, &T) -> Response, ) -> Self

Add route

Source

pub fn any( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for any method

Source

pub fn get( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for GET method

Examples found in repository ?

examples/small-router-simple.rs (line 31)

29fn main() {
30    let router = RouterBuilder::with(())
31        .get("/", home)
32        .get("/hello/:name", hello)
33        .fallback(not_found)
34        .build();
35
36    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
37        .unwrap_or_else(|_| panic!("Can't bind to port"));
38    small_http::serve(listener, move |req| router.handle(req));
39}

More examples

Hide additional examples

examples/small-router-context.rs (line 38)

33fn main() {
34    let ctx = Context {
35        data: "Data".to_string(),
36    };
37    let router = RouterBuilder::with(ctx)
38        .get("/", home)
39        .get("/about", about)
40        .fallback(not_found)
41        .build();
42
43    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
44        .unwrap_or_else(|_| panic!("Can't bind to port"));
45    small_http::serve(listener, move |req| router.handle(req));
46}

examples/small-router-layers.rs (line 58)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}

Source

pub fn head( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for HEAD method

Source

pub fn post( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for POST method

Source

pub fn put( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for PUT method

Source

pub fn delete( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for DELETE method

Source

pub fn connect( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for CONNECT method

Source

pub fn options( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for OPTIONS method

Source

pub fn trace( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for TRACE method

Source

pub fn patch( self, route: impl Into<String>, handler: fn(&Request, &T) -> Response, ) -> Self

Add route for PATCH method

Source

pub fn fallback(self, handler: fn(&Request, &T) -> Response) -> Self

Set fallback handler

Examples found in repository ?

examples/small-router-simple.rs (line 33)

29fn main() {
30    let router = RouterBuilder::with(())
31        .get("/", home)
32        .get("/hello/:name", hello)
33        .fallback(not_found)
34        .build();
35
36    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
37        .unwrap_or_else(|_| panic!("Can't bind to port"));
38    small_http::serve(listener, move |req| router.handle(req));
39}

More examples

Hide additional examples

examples/small-router-context.rs (line 40)

33fn main() {
34    let ctx = Context {
35        data: "Data".to_string(),
36    };
37    let router = RouterBuilder::with(ctx)
38        .get("/", home)
39        .get("/about", about)
40        .fallback(not_found)
41        .build();
42
43    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
44        .unwrap_or_else(|_| panic!("Can't bind to port"));
45    small_http::serve(listener, move |req| router.handle(req));
46}

examples/small-router-layers.rs (line 60)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}

Source

pub fn build(self) -> Router<T>

Build router

Examples found in repository ?

examples/small-router-simple.rs (line 34)

29fn main() {
30    let router = RouterBuilder::with(())
31        .get("/", home)
32        .get("/hello/:name", hello)
33        .fallback(not_found)
34        .build();
35
36    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
37        .unwrap_or_else(|_| panic!("Can't bind to port"));
38    small_http::serve(listener, move |req| router.handle(req));
39}

More examples

Hide additional examples

examples/small-router-context.rs (line 41)

33fn main() {
34    let ctx = Context {
35        data: "Data".to_string(),
36    };
37    let router = RouterBuilder::with(ctx)
38        .get("/", home)
39        .get("/about", about)
40        .fallback(not_found)
41        .build();
42
43    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
44        .unwrap_or_else(|_| panic!("Can't bind to port"));
45    small_http::serve(listener, move |req| router.handle(req));
46}

examples/small-router-layers.rs (line 61)

51fn main() {
52    let ctx = Context {
53        data: "Data".to_string(),
54    };
55    let router = RouterBuilder::with(ctx)
56        .pre_layer(cors_pre_layer)
57        .post_layer(cors_post_layer)
58        .get("/", home)
59        .get("/about", about)
60        .fallback(not_found)
61        .build();
62
63    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
64        .unwrap_or_else(|_| panic!("Can't bind to port"));
65    small_http::serve(listener, move |req| router.handle(req));
66}