SYMBOL INDEX (611 symbols across 64 files)

FILE: examples/echo.rs
  function echo (line 12) | async fn echo(ctx: &mut Context) -> roa::Result {
  function main (line 19) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: examples/hello-world.rs
  function main (line 11) | async fn main() -> anyhow::Result<()> {

FILE: examples/https.rs
  function serve_file (line 17) | async fn serve_file(ctx: &mut Context) -> roa::Result {
  function main (line 23) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: examples/restful-api.rs
  type User (line 25) | struct User {
  type Database (line 31) | struct Database {
    method new (line 36) | fn new() -> Self {
    method create (line 42) | async fn create(&self, user: User) -> usize {
    method retrieve (line 46) | async fn retrieve(&self, id: usize) -> Result<User> {
    method update (line 53) | async fn update(&self, id: usize, new_user: &mut User) -> Result {
    method delete (line 63) | async fn delete(&self, id: usize) -> Result<User> {
  function create_user (line 71) | async fn create_user(ctx: &mut Context<Database>) -> Result {
  function get_user (line 79) | async fn get_user(ctx: &mut Context<Database>) -> Result {
  function update_user (line 85) | async fn update_user(ctx: &mut Context<Database>) -> Result {
  function delete_user (line 92) | async fn delete_user(ctx: &mut Context<Database>) -> Result {
  function main (line 99) | async fn main() -> StdResult<(), Box<dyn std::error::Error>> {

FILE: examples/serve-file.rs
  type Dir (line 26) | struct Dir<'a> {
  type DirInfo (line 33) | struct DirInfo {
  type FileInfo (line 39) | struct FileInfo {
  function new (line 47) | fn new(title: &'a str, root: &'a str) -> Self {
  function path_checker (line 57) | async fn path_checker(ctx: &mut Context, next: Next<'_>) -> Result {
  function serve_path (line 65) | async fn serve_path(ctx: &mut Context) -> Result {
  function serve_root (line 79) | async fn serve_root(ctx: &mut Context) -> Result {
  function serve_dir (line 83) | async fn serve_dir(ctx: &mut Context, path: &str) -> Result {
  function format_time (line 119) | fn format_time(time: SystemTime) -> String {
  function main (line 125) | async fn main() -> StdResult<(), Box<dyn std::error::Error>> {

FILE: examples/websocket-echo.rs
  function main (line 18) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: examples/welcome.rs
  function main (line 13) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: integration/diesel-example/src/bin/api.rs
  function main (line 9) | async fn main() -> anyhow::Result<()> {

FILE: integration/diesel-example/src/data_object.rs
  type NewPost (line 8) | pub struct NewPost {

FILE: integration/diesel-example/src/endpoints.rs
  function post_router (line 14) | pub fn post_router() -> Router<State> {
  function create_post (line 20) | async fn create_post(ctx: &mut Context<State>) -> Result {
  function get_post (line 38) | async fn get_post(ctx: &mut Context<State>) -> Result {
  function update_post (line 49) | async fn update_post(ctx: &mut Context<State>) -> Result {
  function delete_post (line 71) | async fn delete_post(ctx: &mut Context<State>) -> Result {

FILE: integration/diesel-example/src/lib.rs
  type State (line 14) | pub struct State(pub Pool<SqliteConnection>);
    method as_ref (line 17) | fn as_ref(&self) -> &Pool<SqliteConnection> {
  function create_pool (line 22) | pub fn create_pool() -> anyhow::Result<State> {

FILE: integration/diesel-example/src/models.rs
  type Post (line 5) | pub struct Post {

FILE: integration/diesel-example/tests/restful.rs
  type NewPost (line 11) | pub struct NewPost<'a> {
  function eq (line 18) | fn eq(&self, other: &Post) -> bool {
  function test (line 24) | async fn test() -> anyhow::Result<()> {

FILE: integration/juniper-example/src/main.rs
  type NewPost (line 32) | struct NewPost {
  type Query (line 38) | struct Query;
    method post (line 44) | async fn post(
  type Mutation (line 64) | struct Mutation;
    method create_post (line 70) | async fn create_post(
    method update_post (line 91) | async fn update_post(
    method delete_post (line 120) | async fn delete_post(&self, ctx: &JuniperContext<State>, id: i32) -> F...
  function main (line 136) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: integration/juniper-example/src/models.rs
  type Post (line 7) | pub struct Post {

FILE: integration/multipart-example/src/main.rs
  function get_form (line 14) | async fn get_form(ctx: &mut Context) -> roa::Result {
  function post_file (line 19) | async fn post_file(ctx: &mut Context) -> roa::Result {
  function main (line 38) | async fn main() -> Result<(), Box<dyn StdError>> {

FILE: integration/websocket-example/src/main.rs
  type Sender (line 21) | type Sender = SplitSink<SocketStream, Message>;
  type Channel (line 22) | type Channel = Slab<Mutex<Sender>>;
  type SyncChannel (line 24) | struct SyncChannel(Arc<RwLock<Channel>>);
    method new (line 27) | fn new() -> Self {
    method broadcast (line 31) | async fn broadcast(&self, message: Message) {
    method send (line 40) | async fn send(&self, index: usize, message: Message) {
    method register (line 46) | async fn register(&self, sender: Sender) -> usize {
    method deregister (line 50) | async fn deregister(&self, index: usize) -> Sender {
  function handle_message (line 55) | async fn handle_message(
  function route (line 75) | fn route(prefix: &'static str) -> Result<RouteTable<SyncChannel>, Router...
  function main (line 104) | async fn main() -> Result<(), Box<dyn StdError>> {
  function echo (line 128) | async fn echo() -> Result<(), Box<dyn StdError>> {
  function broadcast (line 154) | async fn broadcast() -> Result<(), Box<dyn StdError>> {

FILE: roa-async-std/src/listener.rs
  type Listener (line 9) | pub trait Listener {
    method bind (line 14) | fn bind(self, addr: impl ToSocketAddrs) -> std::io::Result<(SocketAddr...
    method listen (line 17) | fn listen(
    method run (line 43) | fn run(self) -> std::io::Result<(SocketAddr, Self::Server)>;
    type Server (line 51) | type Server = Server<TcpIncoming, Self, Executor>;
    method bind (line 52) | fn bind(self, addr: impl ToSocketAddrs) -> std::io::Result<(SocketAddr...
    method listen (line 58) | fn listen(
    method run (line 68) | fn run(self) -> std::io::Result<(SocketAddr, Self::Server)> {
  function incoming (line 84) | async fn incoming() -> Result<(), Box<dyn Error>> {

FILE: roa-async-std/src/net.rs
  type TcpIncoming (line 18) | pub struct TcpIncoming {
    method bind (line 32) | pub fn bind(addr: impl ToSocketAddrs) -> io::Result<Self> {
    method from_std (line 38) | pub fn from_std(listener: StdListener) -> io::Result<Self> {
    method local_addr (line 51) | pub fn local_addr(&self) -> SocketAddr {
    method set_nodelay (line 56) | pub fn set_nodelay(&mut self, enabled: bool) -> &mut Self {
    method set_sleep_on_errors (line 76) | pub fn set_sleep_on_errors(&mut self, val: bool) {
    method poll_stream (line 81) | fn poll_stream(
    method fmt (line 177) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type BoxedAccept (line 27) | type BoxedAccept<'a> =
  type Conn (line 141) | type Conn = AddrStream<AsyncStream<TcpStream>>;
  type Error (line 142) | type Error = io::Error;
  method poll_accept (line 145) | fn poll_accept(
  method drop (line 155) | fn drop(&mut self) {
  function is_connection_error (line 167) | fn is_connection_error(e: &io::Error) -> bool {
  function incoming (line 198) | async fn incoming() -> Result<(), Box<dyn Error>> {

FILE: roa-async-std/src/runtime.rs
  type FutureObj (line 7) | pub type FutureObj = Pin<Box<dyn 'static + Send + Future<Output = ()>>>;
  type BlockingObj (line 10) | pub type BlockingObj = Box<dyn 'static + Send + FnOnce()>;
  type Exec (line 20) | pub struct Exec;
  method spawn (line 24) | fn spawn(&self, fut: FutureObj) {
  method spawn_blocking (line 29) | fn spawn_blocking(&self, task: BlockingObj) {
  function exec (line 45) | async fn exec() -> Result<(), Box<dyn Error>> {

FILE: roa-core/src/app.rs
  type App (line 85) | pub struct App<S, T> {
  type HttpService (line 92) | pub struct HttpService<S, E> {
  function map_service (line 101) | fn map_service<U>(self, mapper: impl FnOnce(T) -> U) -> App<S, U> {
  function with_exec (line 117) | pub fn with_exec(state: S, exec: impl 'static + Send + Sync + Spawn) -> ...
  function gate (line 131) | pub fn gate<M>(self, middleware: M) -> App<S, Chain<T, M>>
  function end (line 139) | pub fn end<E>(self, endpoint: E) -> App<S, Arc<Chain<T, E>>>
  function accept (line 152) | pub fn accept<I, IO>(self, incoming: I) -> Server<I, Self, Executor>
  function http_service (line 166) | pub fn http_service(&self) -> HttpService<S, E>
  type AppFuture (line 190) | type AppFuture<S, E> =
  type Response (line 199) | type Response = HttpService<S, E>;
  type Error (line 200) | type Error = std::io::Error;
  type Future (line 201) | type Future = AppFuture<S, E>;
  function call (line 205) | fn call(&mut self, stream: &AddrStream<IO>) -> Self::Future {
  type HttpFuture (line 214) | type HttpFuture =
  type Response (line 222) | type Response = HttpResponse<HyperBody>;
  type Error (line 223) | type Error = Infallible;
  type Future (line 224) | type Future = HttpFuture;
  function call (line 228) | fn call(&mut self, req: HttpRequest<HyperBody>) -> Self::Future {
  function new (line 238) | pub fn new(endpoint: Arc<E>, remote_addr: SocketAddr, exec: Executor, st...
  function serve (line 249) | pub async fn serve(self, req: Request) -> Response
  method clone (line 276) | fn clone(&self) -> Self {
  function gate_simple (line 293) | async fn gate_simple() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa-core/src/app/future.rs
  type SendFuture (line 13) | pub struct SendFuture<F>(pub F);
  type Output (line 19) | type Output = F::Output;
  method poll (line 21) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: roa-core/src/app/runtime.rs
  function state (line 8) | pub fn state(state: S) -> Self {
  function new (line 17) | pub fn new() -> Self {
  method default (line 24) | fn default() -> Self {
  type Exec (line 29) | pub struct Exec;
  method spawn (line 33) | fn spawn(&self, fut: FutureObj) {
  method spawn_blocking (line 38) | fn spawn_blocking(&self, task: BlockingObj) {

FILE: roa-core/src/app/stream.rs
  type AddrStream (line 12) | pub struct AddrStream<IO> {
  function new (line 23) | pub fn new(remote_addr: SocketAddr, stream: IO) -> AddrStream<IO> {
  method poll_read (line 37) | fn poll_read(
  method poll_write (line 56) | fn poll_write(
  method poll_flush (line 67) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> P...
  method poll_shutdown (line 72) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -...
  method fmt (line 78) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: roa-core/src/body.rs
  constant DEFAULT_CHUNK_SIZE (line 10) | const DEFAULT_CHUNK_SIZE: usize = 4096;
  type Body (line 36) | pub enum Body {
    method empty (line 54) | pub fn empty() -> Self {
    method once (line 60) | pub fn once(bytes: impl Into<Bytes>) -> Self {
    method stream (line 66) | pub fn stream<S>(stream: S) -> Self
    method write_stream (line 75) | pub fn write_stream(
    method write_reader (line 96) | pub fn write_reader(
    method write_chunk (line 105) | pub fn write_chunk(
    method write (line 115) | pub fn write(&mut self, data: impl Into<Bytes>) -> &mut Self {
  type Segment (line 49) | pub struct Segment(Option<Pin<Box<dyn Stream<Item = io::Result<Bytes>> +...
    method new (line 128) | fn new(stream: impl Stream<Item = io::Result<Bytes>> + Sync + Send + '...
  function from (line 135) | fn from(body: Body) -> Self {
  method default (line 146) | fn default() -> Self {
  type ReaderStream (line 151) | pub struct ReaderStream<R> {
  function new (line 158) | fn new(reader: R, chunk_size: usize) -> Self {
  type Item (line 167) | type Item = io::Result<Bytes>;
  method poll_next (line 169) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Item (line 185) | type Item = io::Result<Bytes>;
  method poll_next (line 187) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type Item (line 201) | type Item = io::Result<Bytes>;
  method poll_next (line 203) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  function read_body (line 220) | async fn read_body(body: Body) -> io::Result<String> {
  function body_empty (line 227) | async fn body_empty() -> std::io::Result<()> {
  function body_single (line 234) | async fn body_single() -> std::io::Result<()> {
  function body_multiple (line 242) | async fn body_multiple() -> std::io::Result<()> {
  function body_composed (line 250) | async fn body_composed() -> std::io::Result<()> {

FILE: roa-core/src/context.rs
  type Context (line 36) | pub struct Context<S = ()> {
  function new (line 56) | pub(crate) fn new(request: Request, state: S, exec: Executor, remote_add...
  function uri (line 81) | pub fn uri(&self) -> &Uri {
  function method (line 100) | pub fn method(&self) -> &Method {
  function get (line 122) | pub fn get(&self, name: impl AsHeaderName) -> Option<&str> {
  function must_get (line 149) | pub fn must_get(&self, name: impl AsHeaderName) -> crate::Result<&str> {
  function status (line 174) | pub fn status(&self) -> StatusCode {
  function version (line 193) | pub fn version(&self) -> Version {
  function store_scoped (line 220) | pub fn store_scoped<SC, K, V>(&mut self, scope: SC, key: K, value: V) ->...
  function store (line 248) | pub fn store<K, V>(&mut self, key: K, value: V) -> Option<Arc<V>>
  function load_scoped (line 278) | pub fn load_scoped<'a, SC, V>(&self, key: &'a str) -> Option<Variable<'a...
  function load (line 305) | pub fn load<'a, V>(&self, key: &'a str) -> Option<Variable<'a, V>>
  type PublicScope (line 314) | struct PublicScope;
  type Target (line 317) | type Target = S;
  method deref (line 319) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 326) | fn deref_mut(&mut self) -> &mut Self::Target {
  method clone (line 333) | fn clone(&self) -> Self {
  function status_and_version (line 354) | async fn status_and_version() -> Result<(), Box<dyn Error>> {
  type State (line 366) | struct State {
  function state (line 371) | async fn state() -> Result<(), Box<dyn Error>> {
  function must_get (line 390) | async fn must_get() -> Result<(), Box<dyn Error>> {

FILE: roa-core/src/context/storage.rs
  type Value (line 13) | pub trait Value: Any + Send + Sync {}
  type Storage (line 19) | pub struct Storage(HashMap<TypeId, HashMap<Cow<'static, str>, Arc<dyn An...
    method new (line 100) | pub fn new() -> Self {
    method insert (line 110) | pub fn insert<S, K, V>(&mut self, scope: S, key: K, value: V) -> Optio...
    method get (line 132) | pub fn get<'a, S, V>(&self, key: &'a str) -> Option<Variable<'a, V>>
  type Variable (line 44) | pub struct Variable<'a, V> {
  type Target (line 50) | type Target = V;
  method deref (line 52) | fn deref(&self) -> &Self::Target {
  function new (line 60) | fn new(key: &'a str, value: Arc<V>) -> Self {
  function value (line 66) | pub fn value(self) -> Arc<V> {
  function parse (line 77) | pub fn parse<T>(&self) -> Result<T, Status>
  method default (line 144) | fn default() -> Self {
  function storage (line 158) | fn storage() {
  function variable (line 181) | fn variable() {

FILE: roa-core/src/err.rs
  type Result (line 7) | pub type Result<R = ()> = StdResult<R, Status>;
  type Status (line 82) | pub struct Status {
    method new (line 127) | pub fn new(status_code: StatusCode, message: impl ToString, expose: bo...
    method from (line 141) | fn from(err: E) -> Self {
  method fmt (line 148) | fn fmt(&self, f: &mut Formatter<'_>) -> StdResult<(), std::fmt::Error> {

FILE: roa-core/src/executor.rs
  type FutureObj (line 10) | pub type FutureObj = Pin<Box<dyn 'static + Send + Future<Output = ()>>>;
  type BlockingObj (line 13) | pub type BlockingObj = Box<dyn 'static + Send + FnOnce()>;
  type Spawn (line 16) | pub trait Spawn {
    method spawn (line 18) | fn spawn(&self, fut: FutureObj);
    method spawn_blocking (line 21) | fn spawn_blocking(&self, task: BlockingObj);
    method spawn (line 96) | fn spawn(&self, fut: FutureObj) {
    method spawn_blocking (line 100) | fn spawn_blocking(&self, task: BlockingObj) {
  type Executor (line 26) | pub struct Executor(pub(crate) Arc<dyn 'static + Send + Sync + Spawn>);
    method spawn (line 34) | pub fn spawn<Fut>(&self, fut: Fut) -> JoinHandle<Fut::Output>
    method spawn_blocking (line 50) | pub fn spawn_blocking<T, R>(&self, task: T) -> JoinHandle<R>
    method execute (line 80) | fn execute(&self, fut: F) {
  type JoinHandle (line 29) | pub struct JoinHandle<T>(Receiver<T>);
  type Output (line 66) | type Output = T;
  method poll (line 68) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  type Exec (line 93) | pub struct Exec;
  function spawn (line 106) | async fn spawn() {
  function spawn_blocking (line 112) | async fn spawn_blocking() {

FILE: roa-core/src/group.rs
  type MiddlewareExt (line 7) | pub trait MiddlewareExt<S>: Sized + for<'a> Middleware<'a, S> {
    method chain (line 9) | fn chain<M>(self, next: M) -> Chain<Self, M>
    method end (line 17) | fn end<E>(self, next: E) -> Chain<Self, E>
    method shared (line 25) | fn shared(self) -> Shared<S>
  type EndpointExt (line 34) | pub trait EndpointExt<S>: Sized + for<'a> Endpoint<'a, S> {
    method boxed (line 36) | fn boxed(self) -> Boxed<S>
  type Chain (line 48) | pub struct Chain<T, U>(T, U);
  type Shared (line 51) | pub struct Shared<S>(Arc<dyn for<'a> Middleware<'a, S>>);
  type Boxed (line 54) | pub struct Boxed<S>(Box<dyn for<'a> Endpoint<'a, S>>);
  function handle (line 63) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> Re...
  function handle (line 76) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> Re...
  method clone (line 83) | fn clone(&self) -> Self {
  function call (line 94) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  function call (line 106) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  type Pusher (line 122) | struct Pusher {
    method new (line 128) | fn new(data: usize, vector: Arc<Mutex<Vec<usize>>>) -> Self {
    method handle (line 135) | async fn handle(&'a self, _ctx: &'a mut Context, next: Next<'a>) -> Re...
  function middleware_order (line 144) | async fn middleware_order() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa-core/src/middleware.rs
  type Middleware (line 60) | pub trait Middleware<'a, S = ()>: 'static + Sync + Send {
    method handle (line 62) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> ...
  method handle (line 73) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> Re...
  type Endpoint (line 162) | pub trait Endpoint<'a, S = ()>: 'static + Sync + Send {
    method call (line 164) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result;
  method call (line 175) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  function handle (line 185) | async fn handle(&'a self, _ctx: &'a mut Context<S>, next: Next<'a>) -> R...
  function call (line 195) | async fn call(&'a self, _ctx: &'a mut Context<S>) -> Result {
  method call (line 204) | async fn call(&'a self, _ctx: &'a mut Context<S>) -> Result {
  method call (line 214) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  function call (line 224) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  method call (line 234) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  type Next (line 311) | pub type Next<'a> = &'a mut (dyn Unpin + Future<Output = Result>);
  constant HELLO (line 321) | const HELLO: &str = "Hello, world";
  function status_endpoint (line 324) | async fn status_endpoint() {
  function string_endpoint (line 332) | async fn string_endpoint() {
  function static_slice_endpoint (line 347) | async fn static_slice_endpoint() {
  function redirect_endpoint (line 362) | async fn redirect_endpoint() {

FILE: roa-core/src/request.rs
  type Request (line 10) | pub struct Request {
    method take_raw (line 32) | pub fn take_raw(&mut self) -> http::Request<Body> {
    method raw_body (line 47) | pub fn raw_body(&mut self) -> Body {
    method stream (line 53) | pub fn stream(
    method reader (line 63) | pub fn reader(&mut self) -> impl AsyncRead + Sync + Send + Unpin + 'st...
    method from (line 70) | fn from(req: http::Request<Body>) -> Self {
  method default (line 85) | fn default() -> Self {
  function test (line 98) | async fn test(ctx: &mut Context) -> Result<(), Status> {
  function body_read (line 106) | async fn body_read() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa-core/src/response.rs
  type Response (line 9) | pub struct Response {
    method new (line 25) | pub(crate) fn new() -> Self {
    method into_resp (line 35) | fn into_resp(self) -> http::Response<hyper::Body> {
  type Target (line 51) | type Target = Body;
  method deref (line 53) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 60) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 67) | fn from(value: Response) -> Self {
  method default (line 74) | fn default() -> Self {

FILE: roa-core/src/state.rs
  type State (line 28) | pub trait State: 'static + Clone + Send + Sync + Sized {}

FILE: roa-diesel/src/async_ext.rs
  type SqlQuery (line 12) | pub trait SqlQuery<Conn: 'static + Connection> {
    method execute (line 21) | async fn execute<E>(&self, exec: E) -> Result<usize>
    method load_data (line 42) | async fn load_data<U, Q>(&self, query: Q) -> Result<Vec<U>>
    method get_result (line 56) | async fn get_result<U, Q>(&self, query: Q) -> Result<Option<U>>
    method get_results (line 67) | async fn get_results<U, Q>(&self, query: Q) -> Result<Vec<U>>
    method first (line 80) | async fn first<U, Q>(&self, query: Q) -> Result<Option<U>>
  function execute (line 94) | async fn execute<E>(&self, exec: E) -> Result<usize>
  function load_data (line 124) | async fn load_data<U, Q>(&self, query: Q) -> Result<Vec<U>>
  function get_result (line 147) | async fn get_result<U, Q>(&self, query: Q) -> Result<Option<U>>
  function get_results (line 167) | async fn get_results<U, Q>(&self, query: Q) -> Result<Vec<U>>
  function first (line 184) | async fn first<U, Q>(&self, query: Q) -> Result<Option<U>>

FILE: roa-diesel/src/pool.rs
  type Pool (line 9) | pub type Pool<Conn> = r2d2::Pool<ConnectionManager<Conn>>;
  type WrapConnection (line 12) | pub type WrapConnection<Conn> = PooledConnection<ConnectionManager<Conn>>;
  function make_pool (line 28) | pub fn make_pool<Conn>(url: impl Into<String>) -> Result<Pool<Conn>, Poo...
  function builder (line 36) | pub fn builder<Conn>() -> Builder<ConnectionManager<Conn>>
  type AsyncPool (line 45) | pub trait AsyncPool<Conn>
    method get_conn (line 76) | async fn get_conn(&self) -> Result<WrapConnection<Conn>, Status>;
    method get_timeout (line 82) | async fn get_timeout(&self, timeout: Duration) -> Result<WrapConnectio...
    method pool_state (line 85) | async fn pool_state(&self) -> r2d2::State;
  function get_conn (line 95) | async fn get_conn(&self) -> Result<WrapConnection<Conn>, Status> {
  function get_timeout (line 101) | async fn get_timeout(&self, timeout: Duration) -> Result<WrapConnection<...
  function pool_state (line 110) | async fn pool_state(&self) -> r2d2::State {

FILE: roa-juniper/src/lib.rs
  type JuniperContext (line 18) | pub struct JuniperContext<S>(Context<S>);
  type Target (line 23) | type Target = Context<S>;
  method deref (line 25) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 31) | fn deref_mut(&mut self) -> &mut Self::Target {
  type GraphQL (line 37) | pub struct GraphQL<QueryT, MutationT, SubscriptionT, Sca>(
  function call (line 60) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {

FILE: roa/src/body.rs
  type PowerBody (line 107) | pub trait PowerBody {
    method read (line 109) | async fn read(&mut self) -> Result<Vec<u8>>;
    method read_json (line 114) | async fn read_json<B>(&mut self) -> Result<B>
    method read_form (line 121) | async fn read_form<B>(&mut self) -> Result<B>
    method read_multipart (line 128) | async fn read_multipart(&mut self) -> Result<Multipart>;
    method write_json (line 133) | fn write_json<B>(&mut self, data: &B) -> Result
    method render (line 140) | fn render<B>(&mut self, data: &B) -> Result
    method write (line 145) | fn write<B>(&mut self, data: B)
    method write_reader (line 150) | fn write_reader<B>(&mut self, reader: B)
    method write_file (line 157) | async fn write_file<P>(&mut self, path: P, typ: DispositionType) -> Re...
    method read (line 165) | async fn read(&mut self) -> Result<Vec<u8>> {
    method read_json (line 176) | async fn read_json<B>(&mut self) -> Result<B>
    method read_form (line 189) | async fn read_form<B>(&mut self) -> Result<B>
    method read_multipart (line 200) | async fn read_multipart(&mut self) -> Result<Multipart> {
    method write_json (line 221) | fn write_json<B>(&mut self, data: &B) -> Result
    method render (line 232) | fn render<B>(&mut self, data: &B) -> Result
    method write (line 244) | fn write<B>(&mut self, data: B)
    method write_reader (line 253) | fn write_reader<B>(&mut self, reader: B)
    method write_file (line 263) | async fn write_file<P>(&mut self, path: P, typ: DispositionType) -> Re...
  type UserDto (line 287) | struct UserDto {
  type User (line 294) | struct User<'a> {
  function eq (line 300) | fn eq(&self, other: &UserDto) -> bool {
  constant USER (line 306) | const USER: User = User {
  function read_json (line 313) | async fn read_json() -> Result<(), Box<dyn Error>> {
  function read_form (line 334) | async fn read_form() -> Result<(), Box<dyn Error>> {
  function render (line 355) | async fn render() -> Result<(), Box<dyn Error>> {
  function write (line 368) | async fn write() -> Result<(), Box<dyn Error>> {
  function write_octet (line 383) | async fn write_octet() -> Result<(), Box<dyn Error>> {
  constant FILE_PATH (line 415) | const FILE_PATH: &str = "../assets/author.txt";
  constant FILE_NAME (line 416) | const FILE_NAME: &str = "author.txt";
  constant FIELD_NAME (line 417) | const FIELD_NAME: &str = "file";
  function post_file (line 419) | async fn post_file(ctx: &mut Context) -> crate::Result {
  function upload (line 440) | async fn upload() -> Result<(), Box<dyn StdError>> {

FILE: roa/src/body/file.rs
  function write_file (line 15) | pub async fn write_file<S: State>(

FILE: roa/src/body/file/content_disposition.rs
  constant HTTP_VALUE (line 12) | const HTTP_VALUE: &AsciiSet = &CONTROLS
  type DispositionType (line 36) | pub enum DispositionType {
  type ContentDisposition (line 45) | pub struct ContentDisposition {
    method new (line 53) | pub(crate) fn new(typ: DispositionType, filename: Option<&str>) -> Self {
  type Error (line 63) | type Error = Status;
  method try_from (line 65) | fn try_from(value: ContentDisposition) -> Result<Self, Self::Error> {
  method fmt (line 75) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  method fmt (line 88) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {

FILE: roa/src/body/file/help.rs
  constant BUG_HELP (line 4) | const BUG_HELP: &str =
  function bug_report (line 8) | pub fn bug_report(message: impl ToString) -> Status {

FILE: roa/src/compress.rs
  type Compress (line 35) | pub struct Compress(pub Level);
    method handle (line 146) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> ...
  type Encoding (line 39) | enum Encoding {
    method parse (line 54) | fn parse(s: &str) -> Result<Option<Encoding>> {
    method to_header_value (line 71) | fn to_header_value(self) -> HeaderValue {
  function select_encoding (line 82) | fn select_encoding(headers: &HeaderMap) -> Result<Option<Encoding>> {
  function accept_encodings (line 101) | fn accept_encodings(headers: &HeaderMap) -> Result<Vec<(Option<Encoding>...
  method default (line 137) | fn default() -> Self {
  type Consumer (line 199) | struct Consumer<S> {
  type Item (line 208) | type Item = io::Result<Bytes>;
  method poll_next (line 209) | fn poll_next(
  type Assert (line 227) | struct Assert(usize);
    method handle (line 231) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> ...
  function end (line 243) | async fn end(ctx: &mut Context) -> crate::Result {
  function compress (line 248) | async fn compress() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/cookie.rs
  type CookieScope (line 33) | struct CookieScope;
  type CookieGetter (line 60) | pub trait CookieGetter {
    method must_cookie (line 62) | fn must_cookie(&mut self, name: &str) -> Result<Arc<Cookie<'static>>>;
    method cookie (line 86) | fn cookie(&self, name: &str) -> Option<Arc<Cookie<'static>>>;
    method must_cookie (line 137) | fn must_cookie(&mut self, name: &str) -> Result<Arc<Cookie<'static>>> {
    method cookie (line 155) | fn cookie(&self, name: &str) -> Option<Arc<Cookie<'static>>> {
  type CookieSetter (line 90) | pub trait CookieSetter {
    method set_cookie (line 112) | fn set_cookie(&mut self, cookie: Cookie<'_>) -> Result;
    method set_cookie (line 162) | fn set_cookie(&mut self, cookie: Cookie<'_>) -> Result {
  function cookie_parser (line 117) | pub async fn cookie_parser<S>(ctx: &mut Context<S>, next: Next<'_>) -> R...
  function must (line 181) | async fn must(ctx: &mut Context) -> crate::Result {
  function none (line 186) | async fn none(ctx: &mut Context) -> crate::Result {
  function parser (line 192) | async fn parser() -> Result<(), Box<dyn std::error::Error>> {
  function cookie (line 217) | async fn cookie() -> Result<(), Box<dyn std::error::Error>> {
  function cookie_action (line 251) | async fn cookie_action() -> Result<(), Box<dyn std::error::Error>> {
  function set_cookie (line 271) | async fn set_cookie() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/cors.rs
  type Cors (line 56) | pub struct Cors {
    method new (line 78) | pub fn new() -> Self {
    method builder (line 83) | pub fn builder() -> Builder {
    method handle (line 241) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> ...
  type Builder (line 67) | pub struct Builder {
    method allow_credentials (line 90) | pub fn allow_credentials(mut self, allow: bool) -> Self {
    method allow_method (line 96) | pub fn allow_method(mut self, method: Method) -> Self {
    method allow_methods (line 102) | pub fn allow_methods(mut self, methods: impl IntoIterator<Item = Metho...
    method allow_header (line 112) | pub fn allow_header<H>(mut self, header: H) -> Self
    method allow_headers (line 127) | pub fn allow_headers<I>(mut self, headers: I) -> Self
    method expose_header (line 145) | pub fn expose_header<H>(mut self, header: H) -> Self
    method expose_headers (line 160) | pub fn expose_headers<I>(mut self, headers: I) -> Self
    method allow_origin (line 178) | pub fn allow_origin<H>(mut self, origin: H) -> Self
    method max_age (line 188) | pub fn max_age(mut self, seconds: u64) -> Self {
    method build (line 198) | pub fn build(self) -> Cors {
  function end (line 344) | async fn end(ctx: &mut Context) -> crate::Result {
  function default_cors (line 350) | async fn default_cors() -> Result<(), Box<dyn std::error::Error>> {
  function configured_cors (line 462) | async fn configured_cors() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/forward.rs
  type Forward (line 10) | pub trait Forward {
    method host (line 28) | fn host(&self) -> Option<&str>;
    method client_ip (line 44) | fn client_ip(&self) -> IpAddr;
    method forwarded_ips (line 60) | fn forwarded_ips(&self) -> Vec<IpAddr>;
    method forwarded_proto (line 78) | fn forwarded_proto(&self) -> Option<&str>;
    method host (line 83) | fn host(&self) -> Option<&str> {
    method client_ip (line 88) | fn client_ip(&self) -> IpAddr {
    method forwarded_ips (line 98) | fn forwarded_ips(&self) -> Vec<IpAddr> {
    method forwarded_proto (line 111) | fn forwarded_proto(&self) -> Option<&str> {
  function host (line 127) | async fn host() -> Result<(), Box<dyn std::error::Error>> {
  function host_err (line 153) | async fn host_err() -> Result<(), Box<dyn std::error::Error>> {
  function client_ip (line 167) | async fn client_ip() -> Result<(), Box<dyn std::error::Error>> {
  function forwarded_proto (line 193) | async fn forwarded_proto() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/jsonrpc.rs
  type RpcEndpoint (line 60) | pub struct RpcEndpoint<R>(pub Server<R>);
  function call (line 69) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {

FILE: roa/src/jwt.rs
  type JwtScope (line 83) | struct JwtScope;
  function set_www_authenticate (line 90) | fn set_www_authenticate<S>(ctx: &mut Context<S>) {
  function guard_not_set (line 98) | fn guard_not_set() -> Status {
  type JwtVerifier (line 122) | pub trait JwtVerifier<S> {
    method claims (line 124) | fn claims<C>(&self) -> Result<C>
    method verify (line 130) | fn verify<C>(&mut self, validation: &Validation) -> Result<C>
  function guard (line 136) | pub fn guard(secret: DecodingKey) -> JwtGuard {
  type JwtGuard (line 147) | pub struct JwtGuard {
    method new (line 154) | pub fn new(secret: DecodingKey, validation: Validation) -> Self {
    method verify (line 163) | fn verify<S>(&self, ctx: &Context<S>) -> Option<(Bearer, Value)> {
    method handle (line 175) | async fn handle(&'a self, ctx: &'a mut Context<S>, next: Next<'a>) -> ...
  function claims (line 193) | fn claims<C>(&self) -> Result<C>
  function verify (line 205) | fn verify<C>(&mut self, validation: &Validation) -> Result<C>
  type User (line 239) | struct User {
  constant SECRET (line 247) | const SECRET: &[u8] = b"123456";
  function claims (line 250) | async fn claims() -> Result<(), Box<dyn std::error::Error>> {
  function jwt_verify_not_set (line 337) | async fn jwt_verify_not_set() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/logger.rs
  type StreamLogger (line 41) | enum StreamLogger<S> {
  type LogTask (line 54) | struct LogTask {
    method log (line 65) | fn log(&self) -> JoinHandle<()> {
  type Item (line 91) | type Item = io::Result<Bytes>;
  method poll_next (line 93) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Po...
  function logger (line 125) | pub async fn logger<S>(ctx: &mut Context<S>, next: Next<'_>) -> Result {

FILE: roa/src/query.rs
  type QueryScope (line 36) | struct QueryScope;
  type Query (line 76) | pub trait Query {
    method must_query (line 105) | fn must_query<'a>(&self, name: &'a str) -> Result<Variable<'a, String>>;
    method query (line 135) | fn query<'a>(&self, name: &'a str) -> Option<Variable<'a, String>>;
    method must_query (line 151) | fn must_query<'a>(&self, name: &'a str) -> Result<Variable<'a, String>> {
    method query (line 161) | fn query<'a>(&self, name: &'a str) -> Option<Variable<'a, String>> {
  function query_parser (line 140) | pub async fn query_parser<S>(ctx: &mut Context<S>, next: Next<'_>) -> Re...
  function query (line 176) | async fn query() -> Result<(), Box<dyn std::error::Error>> {
  function query_parse (line 197) | async fn query_parse() -> Result<(), Box<dyn std::error::Error>> {
  function query_action (line 216) | async fn query_action() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/router.rs
  type RouterScope (line 73) | struct RouterScope;
  type RouterParam (line 107) | pub trait RouterParam {
    method must_param (line 109) | fn must_param<'a>(&self, name: &'a str) -> Result<Variable<'a, String>>;
    method param (line 139) | fn param<'a>(&self, name: &'a str) -> Option<Variable<'a, String>>;
    method must_param (line 297) | fn must_param<'a>(&self, name: &'a str) -> Result<Variable<'a, String>> {
    method param (line 307) | fn param<'a>(&self, name: &'a str) -> Option<Variable<'a, String>> {
  type Router (line 143) | pub struct Router<S> {
  type RouteTable (line 149) | pub struct RouteTable<S> {
  function new (line 159) | pub fn new() -> Self {
  function on (line 167) | pub fn on(mut self, path: &'static str, endpoint: impl for<'a> Endpoint<...
  function register (line 174) | fn register(&self, endpoint: impl for<'a> Endpoint<'a, S>) -> Boxed<S> {
  function include (line 179) | pub fn include(mut self, prefix: &'static str, router: Router<S>) -> Self {
  function gate (line 188) | pub fn gate(self, next: impl for<'a> Middleware<'a, S>) -> Router<S> {
  function routes (line 200) | pub fn routes(self, prefix: &'static str) -> StdResult<RouteTable<S>, Ro...
  function new (line 213) | fn new() -> Self {
  function insert (line 221) | fn insert(
  method default (line 242) | fn default() -> Self {
  method default (line 251) | fn default() -> Self {
  function call (line 262) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {
  function gate (line 323) | async fn gate(ctx: &mut Context, next: Next<'_>) -> Result<(), Status> {
  function test (line 328) | async fn test(ctx: &mut Context) -> Result<(), Status> {
  function gate_test (line 335) | async fn gate_test() -> Result<(), Box<dyn std::error::Error>> {
  function route (line 346) | async fn route() -> Result<(), Box<dyn std::error::Error>> {
  function conflict_path (line 358) | fn conflict_path() -> Result<(), Box<dyn std::error::Error>> {
  function route_not_found (line 369) | async fn route_not_found() -> Result<(), Box<dyn std::error::Error>> {
  function non_utf8_uri (line 379) | async fn non_utf8_uri() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/router/endpoints.rs
  function method_not_allowed (line 8) | fn method_not_allowed(method: &Method) -> Result {

FILE: roa/src/router/endpoints/dispatcher.rs
  type Dispatcher (line 63) | pub struct Dispatcher<S>(HashMap<Method, Box<dyn for<'a> Endpoint<'a, S>...
  method default (line 89) | fn default() -> Self {
  function call (line 100) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result<()> {

FILE: roa/src/router/endpoints/guard.rs
  constant ALL_METHODS (line 9) | const ALL_METHODS: [Method; 9] = [
  type Guard (line 22) | pub struct Guard<E> {
  function hash_set (line 28) | fn hash_set(methods: impl AsRef<[Method]>) -> HashSet<Method> {
  function allow (line 47) | pub fn allow<E>(methods: impl AsRef<[Method]>, endpoint: E) -> Guard<E> {
  function deny (line 69) | pub fn deny<E>(methods: impl AsRef<[Method]>, endpoint: E) -> Guard<E> {
  function call (line 84) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result {

FILE: roa/src/router/err.rs
  type RouterError (line 7) | pub enum RouterError {
    method from (line 54) | fn from(conflict: Conflict) -> Self {
  type Conflict (line 17) | pub enum Conflict {
  method fmt (line 27) | fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
  method fmt (line 43) | fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
  function conflict_to_string (line 69) | fn conflict_to_string() {
  function err_to_string (line 89) | fn err_to_string() {

FILE: roa/src/router/path.rs
  constant WILDCARD (line 10) | const WILDCARD: &str = r"\*\{(?P<var>\w*)\}";
  constant VARIABLE (line 13) | const VARIABLE: &str = r"/:(?P<var>\w*)/";
  function standardize_path (line 16) | pub fn standardize_path(raw_path: &str) -> String {
  function join_path (line 21) | pub fn join_path<'a>(paths: impl 'a + AsRef<[&'a str]>) -> String {
  function must_build (line 32) | fn must_build(pattern: &str) -> Regex {
  type Path (line 45) | pub enum Path {
  type RegexPath (line 52) | pub struct RegexPath {
  type Err (line 59) | type Err = RouterError;
  method from_str (line 60) | fn from_str(raw_path: &str) -> Result<Self, Self::Err> {
  function path_to_regexp (line 73) | fn path_to_regexp(path: &str) -> Result<Option<(String, HashSet<String>)...
  function var_regex_match (line 136) | fn var_regex_match(path: &str) {
  function var_regex_mismatch (line 146) | fn var_regex_mismatch(path: &str) {
  function wildcard_regex_match (line 155) | fn wildcard_regex_match(path: &str) {
  function wildcard_regex_mismatch (line 164) | fn wildcard_regex_mismatch(path: &str) {
  function path_to_regexp_dynamic_pattern (line 174) | fn path_to_regexp_dynamic_pattern(path: &str) -> String {
  function path_to_regexp_static (line 180) | fn path_to_regexp_static(path: &str) {
  function path_to_regexp_err (line 189) | fn path_to_regexp_err(path: &str) {
  function path_match (line 193) | fn path_match(pattern: &str, path: &str) {
  function path_not_match (line 201) | fn path_not_match(pattern: &str, path: &str) {
  function single_variable_path_match (line 214) | fn single_variable_path_match(path: &str) {
  function multiple_variable_path_match (line 220) | fn multiple_variable_path_match(path: &str) {
  function segment_wildcard_path_match (line 226) | fn segment_wildcard_path_match(path: &str) {
  function full_wildcard_path_match (line 232) | fn full_wildcard_path_match(path: &str) {
  function variable_path_not_match (line 238) | fn variable_path_not_match(path: &str) {
  function must_build_fails (line 244) | fn must_build_fails() {

FILE: roa/src/stream.rs
  type AsyncStream (line 13) | pub struct AsyncStream<IO>(pub IO);
  method poll_read (line 20) | fn poll_read(
  method poll_write (line 36) | fn poll_write(
  method poll_flush (line 45) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 50) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  method poll_read (line 61) | fn poll_read(
  method poll_write (line 79) | fn poll_write(
  method poll_flush (line 90) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_close (line 95) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...

FILE: roa/src/tcp/incoming.rs
  type TcpIncoming (line 18) | pub struct TcpIncoming {
    method bind (line 32) | pub fn bind(addr: impl ToSocketAddrs) -> io::Result<Self> {
    method from_std (line 38) | pub fn from_std(listener: StdListener) -> io::Result<Self> {
    method local_addr (line 52) | pub fn local_addr(&self) -> SocketAddr {
    method set_nodelay (line 57) | pub fn set_nodelay(&mut self, enabled: bool) -> &mut Self {
    method set_sleep_on_errors (line 77) | pub fn set_sleep_on_errors(&mut self, val: bool) {
    method poll_stream (line 82) | fn poll_stream(
    method fmt (line 178) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type BoxedAccept (line 27) | type BoxedAccept<'a> =
  type Conn (line 142) | type Conn = AddrStream<TcpStream>;
  type Error (line 143) | type Error = io::Error;
  method poll_accept (line 146) | fn poll_accept(
  method drop (line 156) | fn drop(&mut self) {
  function is_connection_error (line 168) | fn is_connection_error(e: &io::Error) -> bool {

FILE: roa/src/tcp/listener.rs
  type Listener (line 9) | pub trait Listener {
    method bind (line 14) | fn bind(self, addr: impl ToSocketAddrs) -> std::io::Result<(SocketAddr...
    method listen (line 17) | fn listen(
    method run (line 45) | fn run(self) -> std::io::Result<(SocketAddr, Self::Server)>;
    type Server (line 53) | type Server = Server<TcpIncoming, Self, Executor>;
    method bind (line 54) | fn bind(self, addr: impl ToSocketAddrs) -> std::io::Result<(SocketAddr...
    method listen (line 60) | fn listen(
    method run (line 70) | fn run(self) -> std::io::Result<(SocketAddr, Self::Server)> {

FILE: roa/src/tls/incoming.rs
  type TlsIncoming (line 17) | pub struct TlsIncoming<I> {
  type AcceptFuture (line 22) | type AcceptFuture<IO> =
  type WrapTlsStream (line 26) | pub enum WrapTlsStream<IO> {
  function poll_handshake (line 37) | fn poll_handshake(
  method poll_read (line 50) | fn poll_read(
  method poll_write (line 69) | fn poll_write(
  method poll_write_vectored (line 83) | fn poll_write_vectored(
  method poll_flush (line 97) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io...
  method poll_shutdown (line 107) | fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll...
  function new (line 120) | pub fn new(incoming: I, config: ServerConfig) -> Self {
  type Target (line 129) | type Target = I;
  method deref (line 130) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 136) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Conn (line 146) | type Conn = AddrStream<WrapTlsStream<IO>>;
  type Error (line 147) | type Error = I::Error;
  method poll_accept (line 150) | fn poll_accept(

FILE: roa/src/tls/listener.rs
  function bind (line 12) | pub fn bind(addr: impl ToSocketAddrs, config: ServerConfig) -> io::Resul...
  type TlsListener (line 19) | pub trait TlsListener {
    method bind_tls (line 24) | fn bind_tls(
    method listen_tls (line 31) | fn listen_tls(
    method run_tls (line 71) | fn run_tls(self, config: ServerConfig) -> std::io::Result<(SocketAddr,...
    type Server (line 79) | type Server = Server<TlsIncoming<TcpIncoming>, Self, Executor>;
    method bind_tls (line 80) | fn bind_tls(
    method listen_tls (line 90) | fn listen_tls(
    method run_tls (line 101) | fn run_tls(self, config: ServerConfig) -> std::io::Result<(SocketAddr,...
  function end (line 123) | async fn end(ctx: &mut Context) -> Result<(), Status> {
  function run_tls (line 129) | async fn run_tls() -> Result<(), Box<dyn std::error::Error>> {

FILE: roa/src/websocket.rs
  type SocketStream (line 41) | pub type SocketStream = WebSocketStream<Upgraded>;
  type Websocket (line 80) | pub struct Websocket<F, S, Fut>
  function config (line 103) | fn config(config: Option<WebSocketConfig>, task: F) -> Self {
  function new (line 113) | pub fn new(task: F) -> Self {
  function with_config (line 141) | pub fn with_config(config: WebSocketConfig, task: F) -> Self {
  function call (line 154) | async fn call(&'a self, ctx: &'a mut Context<S>) -> Result<(), Status> {

FILE: tests/logger.rs
  type TestLogger (line 12) | struct TestLogger {
    method enabled (line 16) | fn enabled(&self, metadata: &Metadata) -> bool {
    method log (line 19) | fn log(&self, record: &Record) {
    method flush (line 25) | fn flush(&self) {}
  function init (line 32) | fn init() -> anyhow::Result<()> {
  function log (line 39) | async fn log() -> anyhow::Result<()> {

FILE: tests/restful.rs
  type User (line 17) | struct User {
  type DB (line 23) | struct DB {
    method new (line 29) | fn new() -> Self {
    method add (line 36) | fn add(&mut self, user: User) -> usize {
    method delete_index (line 43) | fn delete_index(&mut self, name: &str, id: usize) {
    method delete (line 54) | fn delete(&mut self, id: usize) -> Option<User> {
    method get (line 64) | fn get(&self, id: usize) -> Option<&User> {
    method get_by_name (line 68) | fn get_by_name(&self, name: &str) -> Vec<(usize, &User)> {
    method update (line 78) | fn update(&mut self, id: usize, new_user: &mut User) -> bool {
  type State (line 94) | struct State(Arc<RwLock<DB>>);
    method new (line 97) | fn new(db: DB) -> Self {
    method add (line 101) | async fn add(&mut self, user: User) -> usize {
    method delete (line 105) | async fn delete(&mut self, id: usize) -> Option<User> {
    method get_user (line 109) | async fn get_user(&self, id: usize) -> Option<User> {
    method get_by_name (line 113) | async fn get_by_name(&self, name: &str) -> Vec<(usize, User)> {
    method get_all (line 123) | async fn get_all(&self) -> Vec<(usize, User)> {
    method update (line 133) | async fn update(&mut self, id: usize, new_user: &mut User) -> bool {
  function create_user (line 138) | async fn create_user(ctx: &mut Context<State>) -> roa::Result {
  function query_user (line 145) | async fn query_user(ctx: &mut Context<State>) -> roa::Result {
  function update_user (line 153) | async fn update_user(ctx: &mut Context<State>) -> roa::Result {
  function delete_user (line 163) | async fn delete_user(ctx: &mut Context<State>) -> roa::Result {
  function crud_router (line 171) | fn crud_router() -> Router<State> {
  function restful_crud (line 178) | async fn restful_crud() -> Result<(), Box<dyn std::error::Error>> {
  function create_batch (line 255) | async fn create_batch(ctx: &mut Context<State>) -> roa::Result {
  function query_batch (line 265) | async fn query_batch(ctx: &mut Context<State>) -> roa::Result {
  function batch_router (line 273) | fn batch_router() -> Router<State> {
  function batch (line 278) | async fn batch() -> Result<(), Box<dyn std::error::Error>> {

FILE: tests/serve-file.rs
  function serve_static_file (line 11) | async fn serve_static_file() -> Result<(), Box<dyn std::error::Error>> {
  function serve_router_variable (line 25) | async fn serve_router_variable() -> Result<(), Box<dyn std::error::Error...
  function serve_router_wildcard (line 41) | async fn serve_router_wildcard() -> Result<(), Box<dyn std::error::Error...
  function serve_gzip (line 57) | async fn serve_gzip() -> Result<(), Box<dyn std::error::Error>> {