hyperlane 19.1.2

A lightweight, high-performance, and cross-platform Rust HTTP server library built on Tokio. It simplifies modern web service development by providing built-in support for middleware, WebSocket, Server-Sent Events (SSE), and raw TCP communication. With a unified and ergonomic API across Windows, Linux, and MacOS, it enables developers to build robust, scalable, and event-driven network applications with minimal overhead and maximum flexibility.
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

use crate::*;

/// A type alias for a shared hook handler.
///
/// This type is used for storing handlers in a shared context, allowing multiple
/// parts of the application to safely access and execute the same handler.
pub type HookHandler<T> = Arc<dyn FnContextPinBox<T>>;

/// A type alias for a hook handler chain.
///
/// This type is used to represent a chain of middleware handlers that can be
/// executed sequentially.
pub type HookHandlerChain<T> = Vec<HookHandler<T>>;

/// A type alias for an asynchronous task.
///
/// This is a common return type for asynchronous handlers, providing a type-erased
/// future that can be easily managed by the async runtime.
pub type AsyncTask = Pin<Box<dyn Future<Output = ()> + Send + 'static>>;

/// A type alias for a boxed future with a generic output that can be sent across threads.
///
/// This is often used to represent an asynchronous task that can be sent across threads.
pub type FutureBox<T> = Pin<Box<dyn Future<Output = T> + Send>>;

/// A type alias for a server control hook handler.
///
/// This type represents a thread-safe, reference-counted function that returns
/// a boxed future when invoked. It is used for server lifecycle hooks such as
/// graceful shutdown and wait operations.
pub type ServerControlHookHandler<T> = Arc<dyn FutureFn<T>>;

/// A type alias for a hook handler factory function.
///
/// This function pointer type is used to create ServerHookHandler instances
/// based on generic types. It allows delayed instantiation of handlers.
pub type ServerHookHandlerFactory = fn() -> ServerHookHandler;

/// Type alias for a shared server hook handler.
///
/// This type allows storing handlers (route and middleware) of different concrete types
/// in the same collection. The handler takes a `&mut Context` and returns
/// a pinned, boxed future that resolves to `()`.
pub type ServerHookHandler = Arc<dyn Fn(&mut Context) -> FutureBox<()> + Send + Sync>;

/// Type alias for a list of server hook handlers.
///
/// Used to store middleware handlers in the request/response processing pipeline.
pub type ServerHookList = Vec<ServerHookHandler>;

/// Type alias for a map of server route handlers.
///
/// Used for fast lookup of exact-match routes.
pub type ServerHookMap = HashMapXxHash3_64<String, ServerHookHandler>;

/// Type alias for a collection of pattern-based server hook route grouped by segment count.
///
/// The outer HashMap uses segment count as key for fast filtering.
/// The inner Vec stores patterns with the same segment count, maintaining insertion order.
pub type ServerHookPatternRoute = HashMapXxHash3_64<usize, Vec<(RoutePattern, ServerHookHandler)>>;