Struct RouterBuilder

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

Router builder

Implementations

impl RouterBuilder<()>

pub fn new() -> Self

Create new router

Examples found in repository

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

fn main() {
    let router = RouterBuilder::new()
        .get("/", home)
        .get("/hello/:name", hello)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

impl<T: Clone> RouterBuilder<T>

pub fn with(ctx: T) -> Self

Create new router with context

Examples found in repository

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

fn main() {
    let ctx = Context {
        shared_data: Arc::new(RwLock::new("Hello".to_string())),
    };
    let router = RouterBuilder::with(ctx)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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 48)

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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 49)

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

Add route

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

Add route for any method

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)

fn main() {
    let router = RouterBuilder::new()
        .get("/", home)
        .get("/hello/:name", hello)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let ctx = Context {
        shared_data: Arc::new(RwLock::new("Hello".to_string())),
    };
    let router = RouterBuilder::with(ctx)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

Add route for HEAD method

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

Add route for POST method

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

Add route for PUT method

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

Add route for DELETE method

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

Add route for CONNECT method

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

Add route for OPTIONS method

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

Add route for TRACE method

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

Add route for PATCH method

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

Set fallback handler

Examples found in repository

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

fn main() {
    let router = RouterBuilder::new()
        .get("/", home)
        .get("/hello/:name", hello)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let ctx = Context {
        shared_data: Arc::new(RwLock::new("Hello".to_string())),
    };
    let router = RouterBuilder::with(ctx)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

Build router

Examples found in repository

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

fn main() {
    let router = RouterBuilder::new()
        .get("/", home)
        .get("/hello/:name", hello)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let router = RouterBuilder::new()
        .pre_layer(cors_pre_layer)
        .post_layer(cors_post_layer)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

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

fn main() {
    let ctx = Context {
        shared_data: Arc::new(RwLock::new("Hello".to_string())),
    };
    let router = RouterBuilder::with(ctx)
        .get("/", home)
        .get("/about", about)
        .fallback(not_found)
        .build();

    let listener = TcpListener::bind((Ipv4Addr::LOCALHOST, 8080))
        .unwrap_or_else(|_| panic!("Can't bind to port"));
    small_http::serve(listener, move |req| router.handle(req));
}

Trait Implementations

impl Default for RouterBuilder<()>

fn default() -> Self

Returns the “default value” for a type.