const-router 0.1.0

Compile-time string-key router with Tower service integration.
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

# const-router

[![Version](https://img.shields.io/crates/v/const-router.svg?style=flat)](https://crates.io/crates/const-router)
[![Documentation](https://img.shields.io/badge/docs-release-brightgreen.svg?style=flat)](https://docs.rs/const-router)
[![License](https://img.shields.io/crates/l/const-router.svg?style=flat)](https://github.com/EAimTY/const-router/blob/master/LICENSE)

`const-router` is a small string-key router that can be built in a `static`.
Routes are declared with a macro, sorted at compile time, and dispatched with a
binary search. The router also implements `tower::Service`.

## Features

- `router!` builds a `Router` from static route keys and handlers.
- `#[handler]` converts sync or async functions returning `Result` into router
  handlers.
- `ExtractKey` lets request types choose the string used for routing.
- The optional `http` feature implements `ExtractKey` for `http::Request<T>`
  using the URI path.

## Example

```rust
use const_router::{handler, router, ExtractKey, Router};

#[derive(Debug)]
struct Request {
    path: &'static str,
}

impl ExtractKey for Request {
    fn extract_key(&self) -> &str {
        self.path
    }
}

#[handler]
fn home(_req: Request) -> Result<&'static str, &'static str> {
    Ok("home")
}

#[handler]
fn not_found() -> Result<&'static str, &'static str> {
    Ok("not found")
}

static ROUTER: Router<Request, &'static str, &'static str> = router! {
    not_found,
    "/" => home,
};

# async fn run() -> Result<(), &'static str> {
let response = ROUTER.handle(Request { path: "/" }).await?;
assert_eq!(response, "home");
# Ok(())
# }
```

## Handler Functions

Handlers can be synchronous or asynchronous functions. They must return
`Result<TResponse, TError>` and may take either zero arguments or one request
argument.

```rust
# use const_router::handler;
# struct Request;
#[handler]
fn with_request(_req: Request) -> Result<&'static str, &'static str> {
    Ok("matched")
}

#[handler]
async fn async_without_request() -> Result<&'static str, &'static str> {
    Ok("fallback")
}
```

## HTTP Requests

Enable the `http` feature to route `http::Request<T>` values by URI path.

```toml
[dependencies]
const-router = { version = "0.1", features = ["http"] }
```

## License

Licensed under either of:

- Apache License, Version 2.0
- MIT license

at your option.