SYMBOL INDEX (4373 symbols across 220 files)

FILE: benchmark/launch.py
  class ServerRunner (line 13) | class ServerRunner:
    method __init__ (line 18) | def __init__(self, impl_name: str, launch_server: list[str], listen_po...
    method run (line 23) | def run(self, log) -> subprocess.Popen:
  class Result (line 34) | class Result:
    method __init__ (line 39) | def __init__(self, success: int, duration: float):
    method __str__ (line 43) | def __str__(self):
    method __repr__ (line 46) | def __repr__(self):
    method average (line 50) | def average(results: list['Result']) -> 'Result':
  class RandomFiles (line 60) | class RandomFiles:
    method __init__ (line 63) | def __init__(self):
    method gen (line 67) | def gen(self, file_size: int) -> str:
  class Certs (line 77) | class Certs:
    method __init__ (line 89) | def __init__(self):
    method gen (line 92) | def gen(self):
  function git_clone (line 138) | def git_clone(owner: str, repo: str, branch: str) -> None:
  function go_quic_runner (line 148) | def go_quic_runner() -> ServerRunner:
  function dquic_runner (line 176) | def dquic_runner() -> ServerRunner:
  function dquic_multi_path_runner (line 201) | def dquic_multi_path_runner() -> ServerRunner:
  function tquic_runner (line 227) | def tquic_runner() -> ServerRunner:
  function quinn_runner (line 250) | def quinn_runner() -> ServerRunner:
  function cf_quiche_runner (line 273) | def cf_quiche_runner() -> ServerRunner:
  class H3Client (line 297) | class H3Client:
    method __init__ (line 302) | def __init__(self, stress: int = 1024*30, requests: int = 8, progress:...
    method run_once (line 315) | def run_once(self, server_runner: ServerRunner, file_size: int, seq: i...
    method run_many (line 375) | def run_many(self, server_runner: ServerRunner, file_size: int, times:...
  function run (line 385) | def run(*runners: ServerRunner) -> dict[dict[str, list[Result]]]:
  function plot_results (line 401) | def plot_results(results: dict[str, dict[str, list[Result]]]):
  function save_results (line 456) | def save_results(results: dict[str, dict[str, list[Result]]]):
  function load_results (line 471) | def load_results(*paths: str) -> dict[str, dict[str, list[Result]]]:

FILE: dquic/examples/echo-client.rs
  type Options (line 23) | struct Options {
  function main (line 62) | async fn main() {
  type Error (line 92) | type Error = Box<dyn std::error::Error + Send + Sync>;
  function run (line 94) | async fn run(options: Options) -> Result<(), Error> {
  function send_and_verify_files (line 125) | async fn send_and_verify_files(
  function process (line 173) | async fn process(client: &Arc<QuicClient>, auth: &Authority, progress: b...
  function new_pb (line 203) | fn new_pb(prefix: impl Into<Cow<'static, str>>, len: u64) -> ProgressBar {
  function send_and_verify_echo (line 210) | async fn send_and_verify_echo(

FILE: dquic/examples/echo-server.rs
  type Options (line 12) | struct Options {
  type Certs (line 43) | struct Certs {
  function main (line 63) | async fn main() {
  function run (line 86) | async fn run(options: Options) -> Result<(), Box<dyn std::error::Error +...
  function serve_echo (line 127) | async fn serve_echo(listeners: Arc<QuicListeners>) -> Result<(), Listene...

FILE: dquic/examples/http-client.rs
  type Options (line 15) | struct Options {
  function main (line 54) | async fn main() {
  type Error (line 81) | type Error = Box<dyn std::error::Error + Send + Sync>;
  function run (line 83) | async fn run(options: Options) -> Result<(), Error> {
  function process (line 126) | async fn process(
  function download (line 156) | async fn download(client: &Arc<QuicClient>, uri: Uri, save: Option<&Path...

FILE: dquic/examples/http-server.rs
  type Options (line 13) | struct Options {
  type Certs (line 61) | struct Certs {
  type Error (line 80) | type Error = Box<dyn std::error::Error + Send + Sync>;
  function main (line 82) | fn main() {
  function run (line 112) | async fn run(options: Options) -> Result<(), Error> {
  function serve_files (line 154) | async fn serve_files(connection: Connection) -> Result<(), Error> {

FILE: dquic/examples/traversal-client.rs
  function main (line 147) | fn main() {}

FILE: dquic/examples/traversal-server.rs
  function main (line 124) | fn main() {}

FILE: dquic/src/cert.rs
  type ToCertificate (line 5) | pub trait ToCertificate {
    method to_certificate (line 6) | fn to_certificate(self) -> Vec<CertificateDer<'static>>;
    method to_certificate (line 10) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 16) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 22) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 28) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 34) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 47) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
    method to_certificate (line 59) | fn to_certificate(self) -> Vec<CertificateDer<'static>> {
  type ToPrivateKey (line 64) | pub trait ToPrivateKey {
    method to_private_key (line 65) | fn to_private_key(self) -> PrivateKeyDer<'static>;
    method to_private_key (line 69) | fn to_private_key(self) -> PrivateKeyDer<'static> {
    method to_private_key (line 75) | fn to_private_key(self) -> PrivateKeyDer<'static> {
    method to_private_key (line 81) | fn to_private_key(self) -> PrivateKeyDer<'static> {
    method to_private_key (line 93) | fn to_private_key(self) -> PrivateKeyDer<'static> {
    method to_private_key (line 104) | fn to_private_key(self) -> PrivateKeyDer<'static> {

FILE: dquic/src/client.rs
  type TlsClientConfig (line 35) | type TlsClientConfig = rustls::ClientConfig;
  type TlsClientConfigBuilder (line 36) | type TlsClientConfigBuilder<T> = ConfigBuilder<TlsClientConfig, T>;
  type QuicClient (line 55) | pub struct QuicClient {
    method bind_ifaces (line 97) | pub fn bind_ifaces(&self) -> HashMap<BindUri, BindInterface> {
    method bind (line 104) | pub async fn bind(&self, bind_uri: impl Into<BindUri>) -> BindInterface {
    method unbind (line 113) | pub fn unbind(&self, bind_uri: &BindUri) -> Option<BindInterface> {
    method new_connection (line 125) | pub fn new_connection(&self, server_name: impl Into<String>) -> Connec...
    method bind_uri_for (line 147) | fn bind_uri_for(source: &Source, ep: &EndpointAddr) -> BindUri {
    method ensure_iface_for (line 170) | async fn ensure_iface_for(&self, source: &Source, ep: &EndpointAddr) {
    method select_or_bind_ifaces (line 182) | async fn select_or_bind_ifaces(
    method probe (line 259) | pub async fn probe(
    method setup_server_endpoint (line 291) | async fn setup_server_endpoint(
    method connected_to_with_source (line 328) | pub async fn connected_to_with_source(
    method connect (line 353) | pub async fn connect(self: &Arc<Self>, server: &str) -> Result<Connect...
    method builder (line 436) | pub fn builder() -> QuicClientBuilder<TlsClientConfigBuilder<WantsVeri...
    method builder_with_crypto_provider (line 443) | pub fn builder_with_crypto_provider(
    method builder_with_tls (line 456) | pub fn builder_with_tls<T>(tls_config: T) -> QuicClientBuilder<T> {
  type ConnectServerError (line 71) | pub enum ConnectServerError {
  type BindInterfaceError (line 89) | pub struct BindInterfaceError {
  type QuicClientBuilder (line 418) | pub struct QuicClientBuilder<T> {
  function with_resolver (line 477) | pub fn with_resolver(mut self, resolver: Arc<dyn Resolve + Send + Sync>)...
  function physical_ifaces (line 482) | pub fn physical_ifaces(mut self, physical_ifaces: &'static Devices) -> S...
  function with_iface_factory (line 495) | pub fn with_iface_factory(mut self, iface_factory: Arc<dyn ProductIO>) -...
  function with_iface_manager (line 501) | pub fn with_iface_manager(mut self, iface_manager: Arc<InterfaceManager>...
  function with_router (line 506) | pub fn with_router(mut self, router: Arc<QuicRouter>) -> Self {
  function with_stun (line 511) | pub fn with_stun(mut self, server: impl Into<Arc<str>>) -> Self {
  function with_locations (line 519) | pub fn with_locations(mut self, locations: Arc<Locations>) -> Self {
  function bind (line 543) | pub async fn bind(mut self, bind_uris: impl IntoIterator<Item = impl Int...
  function prefer_versions (line 558) | pub fn prefer_versions(mut self, versions: impl IntoIterator<Item = u32>...
  function with_token_sink (line 571) | pub fn with_token_sink(self, token_sink: Arc<dyn TokenSink>) -> Self {
  function with_parameters (line 582) | pub fn with_parameters(self, parameters: ClientParameters) -> Self {
  function map_tls (line 586) | fn map_tls<T1>(self, f: impl FnOnce(T) -> T1) -> QuicClientBuilder<T1> {
  function with_name (line 601) | pub fn with_name(mut self, name: impl Into<String>) -> Self {
  function defer_idle_timeout (line 617) | pub fn defer_idle_timeout(mut self, duration: Duration) -> Self {
  function with_streams_concurrency_strategy (line 631) | pub fn with_streams_concurrency_strategy(
  function with_qlog (line 658) | pub fn with_qlog(self, qlogger: Arc<dyn QLog + Send + Sync>) -> Self {
  function with_root_certificates (line 667) | pub fn with_root_certificates(
  function with_webpki_verifier (line 677) | pub fn with_webpki_verifier(
  function with_custom_server_cert_verifier (line 689) | pub fn with_custom_server_cert_verifier(
  function without_verifier (line 701) | pub fn without_verifier(self) -> QuicClientBuilder<TlsClientConfigBuilde...
  function with_cert (line 769) | pub fn with_cert(
  function without_cert (line 782) | pub fn without_cert(self) -> QuicClientBuilder<TlsClientConfig> {
  function with_cert_resolver (line 786) | pub fn with_cert_resolver(
  function with_alpns (line 804) | pub fn with_alpns(mut self, alpns: impl IntoIterator<Item = impl Into<Ve...
  function enable_sslkeylog (line 818) | pub fn enable_sslkeylog(mut self) -> Self {
  function enable_0rtt (line 823) | pub fn enable_0rtt(mut self) -> Self {
  function build (line 829) | pub fn build(self) -> QuicClient {

FILE: dquic/src/common.rs
  type Network (line 27) | pub struct Network {
    method lookup_first_agent (line 53) | async fn lookup_first_agent(
    method init_iface_components (line 75) | fn init_iface_components(
    method bind (line 149) | pub async fn bind(&self, bind_uri: BindUri) -> BindInterface {
    method bind_many (line 174) | pub async fn bind_many(
  method default (line 38) | fn default() -> Self {

FILE: dquic/src/server.rs
  type ServerError (line 45) | pub enum ServerError {
  function from (line 64) | fn from(error: ServerError) -> Self {
  type ListenError (line 76) | pub enum ListenError {
  function from (line 83) | fn from(error: ListenError) -> Self {
  type TlsServerConfigBuilder (line 90) | type TlsServerConfigBuilder<T> = ConfigBuilder<TlsServerConfig, T>;
  type VirtualHosts (line 93) | pub struct VirtualHosts(Arc<DashMap<String, Server>>);
  method resolve (line 96) | fn resolve(&self, client_hello: rustls::server::ClientHello) -> Option<A...
  type Server (line 103) | pub struct Server {
    method fmt (line 111) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method bind_interfaces (line 120) | pub fn bind_interfaces(&self) -> HashMap<BindUri, BindInterface> {
    method bind (line 127) | pub async fn bind(&self, bind_uris: impl IntoIterator<Item = impl Into...
    method get_iface (line 134) | pub fn get_iface(&self, bind_uri: &BindUri) -> Option<BindInterface> {
    method remove_iface (line 140) | pub fn remove_iface(&self, bind_uri: &BindUri) -> Option<BindInterface> {
    method certified_key (line 144) | pub fn certified_key(&self) -> Arc<CertifiedKey> {
    method update_ocsp (line 148) | pub fn update_ocsp(&self, ocsp: Option<Vec<u8>>) {
  type Incomings (line 157) | type Incomings = BoundQueue<((Connection, String, Pathway, Link), OwnedS...
  type QuicListeners (line 184) | pub struct QuicListeners {
    method add_server (line 215) | pub async fn add_server(
    method remove_server (line 278) | pub fn remove_server(&self, server_name: &str) -> bool {
    method get_server (line 283) | pub fn get_server<'l>(&'l self, server_name: &str) -> Option<impl Dere...
    method get_server_mut (line 288) | pub fn get_server_mut<'l>(
    method servers (line 295) | pub fn servers(&self) -> Vec<String> {
    method accept (line 315) | pub async fn accept(&self) -> Result<(Connection, String, Pathway, Lin...
    method shutdown (line 326) | pub fn shutdown(&self) {
    method try_accept_connection (line 372) | pub(crate) fn try_accept_connection(&self, packet: Packet, (bind_uri, ...
    method builder (line 473) | pub fn builder() -> QuicListenersBuilder<TlsServerConfigBuilder<WantsV...
    method builder_with_crypto_provider (line 480) | pub fn builder_with_crypto_provider(
    method builder_with_tls (line 492) | pub fn builder_with_tls<T>(tls_config: T) -> QuicListenersBuilder<T> {
  type ListenersShutdown (line 305) | pub struct ListenersShutdown;
  method drop (line 333) | fn drop(&mut self) {
  type ServerAuther (line 338) | struct ServerAuther {
  method verify_client_name (line 345) | fn verify_client_name(
  method verify_client_agent (line 361) | fn verify_client_agent(&self, _: &LocalAgent, _: &RemoteAgent) -> Client...
  type QuicListenersBuilder (line 452) | pub struct QuicListenersBuilder<T> {
  function with_resolver (line 515) | pub fn with_resolver(mut self, resolver: Arc<dyn Resolve + Send + Sync>)...
  function with_physical_ifaces (line 520) | pub fn with_physical_ifaces(mut self, physical_ifaces: &'static Devices)...
  function with_iface_factory (line 532) | pub fn with_iface_factory(mut self, iface_factory: Arc<dyn ProductIO + '...
  function with_iface_manager (line 537) | pub fn with_iface_manager(mut self, iface_manager: Arc<InterfaceManager>...
  function with_router (line 549) | pub fn with_router(mut self, router: Arc<QuicRouter>) -> Self {
  function with_stun (line 554) | pub fn with_stun(mut self, stun_server: impl Into<Arc<str>>) -> Self {
  function with_locations (line 562) | pub fn with_locations(mut self, locations: Arc<Locations>) -> Self {
  function with_supported_versions (line 570) | pub fn with_supported_versions(mut self, versions: impl IntoIterator<Ite...
  function with_token_provider (line 581) | pub fn with_token_provider(self, token_provider: Arc<dyn TokenProvider>)...
  function with_parameters (line 595) | pub fn with_parameters(mut self, parameters: ServerParameters) -> Self {
  function enable_anti_port_scan (line 622) | pub fn enable_anti_port_scan(mut self) -> Self {
  function with_client_auther (line 661) | pub fn with_client_auther(mut self, client_auther: impl AuthClient + 'st...
  function map_tls (line 666) | fn map_tls<T1>(self, f: impl FnOnce(T) -> T1) -> QuicListenersBuilder<T1> {
  function with_streams_concurrency_strategy (line 689) | pub fn with_streams_concurrency_strategy(
  function defer_idle_timeout (line 708) | pub fn defer_idle_timeout(mut self, duration: Duration) -> Self {
  function with_qlog (line 730) | pub fn with_qlog(self, qlogger: Arc<dyn QLog + Send + Sync>) -> Self {
  function with_client_cert_verifier (line 737) | pub fn with_client_cert_verifier(
  function without_client_cert_verifier (line 750) | pub fn without_client_cert_verifier(self) -> QuicListenersBuilder<TlsSer...
  function with_alpns (line 768) | pub fn with_alpns(mut self, alpn: impl IntoIterator<Item = impl Into<Vec...
  function enable_0rtt (line 775) | pub fn enable_0rtt(mut self) -> Self {
  function listen (line 794) | pub fn listen(self, backlog: usize) -> Result<Arc<QuicListeners>, Listen...

FILE: dquic/tests/auth.rs
  function client_without_verify (line 26) | fn client_without_verify() -> Result<(), BoxError> {
  type ClientNameAuther (line 58) | struct ClientNameAuther<const SILENT_REFUSE: bool>;
  method verify_client_name (line 61) | fn verify_client_name(
  method verify_client_agent (line 73) | fn verify_client_agent(&self, _: &LocalAgent, _: &RemoteAgent) -> Client...
  function launch_client_auth_test_server (line 78) | async fn launch_client_auth_test_server<const SILENT_REFUSE: bool>(
  function auth_client_name (line 108) | fn auth_client_name() -> Result<(), BoxError> {
  function auth_client_name_incorrect_name (line 147) | fn auth_client_name_incorrect_name() -> Result<(), BoxError> {
  function auth_client_refuse (line 188) | fn auth_client_refuse() -> Result<(), BoxError> {
  function auth_client_refuse_silently (line 232) | fn auth_client_refuse_silently() -> Result<(), BoxError> {
  type Message (line 282) | struct Message {
  constant SIGNATURE_SCHEME (line 287) | const SIGNATURE_SCHEME: rustls::SignatureScheme = rustls::SignatureSchem...
  function send_and_verify_echo_with_sign_verify (line 289) | async fn send_and_verify_echo_with_sign_verify(
  function echo_stream_with_sign_verify (line 322) | async fn echo_stream_with_sign_verify(
  function serve_echo_with_sign_verify (line 341) | pub async fn serve_echo_with_sign_verify(listeners: Arc<QuicListeners>) {
  function launch_echo_with_sign_verify_server (line 360) | async fn launch_echo_with_sign_verify_server(
  function sign_and_verify (line 389) | fn sign_and_verify() -> Result<(), BoxError> {

FILE: dquic/tests/common/mod.rs
  function qlogger (line 25) | pub fn qlogger() -> Arc<dyn QLog + Send + Sync> {
  type BoxError (line 30) | pub type BoxError = Box<dyn std::error::Error + Send + Sync>;
  function run (line 32) | pub fn run<F: Future>(future: F) -> F::Output {
  function launch_test_client (line 68) | pub fn launch_test_client(
  function get_server_addr (line 86) | pub fn get_server_addr(listeners: &QuicListeners) -> SocketAddr {
  constant CA_CERT (line 102) | pub const CA_CERT: &[u8] = include_bytes!("../../../tests/keychain/local...
  constant SERVER_CERT (line 103) | pub const SERVER_CERT: &[u8] = include_bytes!("../../../tests/keychain/l...
  constant SERVER_KEY (line 104) | pub const SERVER_KEY: &[u8] = include_bytes!("../../../tests/keychain/lo...
  constant CLIENT_CERT (line 105) | pub const CLIENT_CERT: &[u8] = include_bytes!("../../../tests/keychain/l...
  constant CLIENT_KEY (line 106) | pub const CLIENT_KEY: &[u8] = include_bytes!("../../../tests/keychain/lo...
  constant TEST_DATA (line 107) | pub const TEST_DATA: &[u8] = include_bytes!("mod.rs");

FILE: dquic/tests/echo.rs
  function single_stream (line 19) | fn single_stream() -> Result<(), BoxError> {
  function signal_big_stream (line 39) | fn signal_big_stream() -> Result<(), BoxError> {
  function empty_stream (line 60) | fn empty_stream() -> Result<(), BoxError> {
  function shutdown (line 80) | fn shutdown() -> Result<(), BoxError> {
  function idle_timeout (line 134) | fn idle_timeout() -> Result<(), BoxError> {
  function double_connections (line 164) | fn double_connections() -> Result<(), BoxError> {
  constant PARALLEL_ECHO_CONNS (line 214) | const PARALLEL_ECHO_CONNS: usize = 3;
  constant PARALLEL_ECHO_STREAMS (line 215) | const PARALLEL_ECHO_STREAMS: usize = 2;
  function parallel_stream (line 218) | fn parallel_stream() -> Result<(), BoxError> {
  function parallel_big_stream (line 275) | fn parallel_big_stream() -> Result<(), BoxError> {
  function limited_streams (line 329) | fn limited_streams() -> Result<(), BoxError> {

FILE: dquic/tests/echo_common/mod.rs
  function echo_stream (line 11) | pub async fn echo_stream(mut reader: StreamReader, mut writer: StreamWri...
  function serve_echo (line 17) | pub async fn serve_echo(listeners: Arc<QuicListeners>) {
  function send_and_verify_echo (line 29) | pub async fn send_and_verify_echo(connection: &Connection, data: &[u8]) ...
  function launch_echo_server (line 51) | pub async fn launch_echo_server(

FILE: dquic/tests/traversal.rs
  type TestCase (line 29) | pub struct TestCase {
  constant STUN_SERVERS (line 35) | pub const STUN_SERVERS: &str = "10.10.0.64:20002";
  constant CASES (line 37) | pub const CASES: [TestCase; 10] = [
  function launch_stun_test_server (line 165) | async fn launch_stun_test_server(server_case: TestCase) -> Arc<QuicListe...
  function launch_stun_test_client (line 201) | async fn launch_stun_test_client(client_case: TestCase) -> Arc<QuicClien...
  function test_punch_case (line 236) | async fn test_punch_case(client_nat: NatType, server_nat: NatType) {
  function get_stun_data (line 262) | async fn get_stun_data(server_iface: dquic::qinterface::Interface) -> Ve...
  function launch_client (line 293) | async fn launch_client(client_case: TestCase, server_ep: EndpointAddr) {
  type Error (line 345) | pub type Error = Box<dyn std::error::Error + Send + Sync>;
  function test_knock_ttl_is_1_in_tests (line 348) | fn test_knock_ttl_is_1_in_tests() {

FILE: h3-shim/examples/h3-client.rs
  type Options (line 22) | struct Options {
  function main (line 88) | async fn main() {
  type Error (line 117) | type Error = Box<dyn std::error::Error + Send + Sync>;
  function run (line 119) | async fn run(options: Options) -> Result<(), Error> {
  function download_files_with_progress (line 222) | async fn download_files_with_progress(

FILE: h3-shim/examples/h3-server.rs
  type Options (line 17) | struct Options {
  type Certs (line 65) | struct Certs {
  function main (line 84) | fn main() {
  function run (line 117) | async fn run(options: Options) -> Result<(), Box<dyn std::error::Error +...
  function handle_connection (line 186) | async fn handle_connection<T>(
  function handle_request (line 214) | async fn handle_request<T>(
  function test_name (line 258) | fn test_name() {}

FILE: h3-shim/src/conn.rs
  type QuicConnection (line 17) | pub struct QuicConnection {
    method new (line 34) | pub fn new(conn: Arc<Connection>) -> Self {
    type BidiStream (line 47) | type BidiStream = BidiStream<B>;
    type SendStream (line 49) | type SendStream = SendStream<B>;
    method poll_open_bidi (line 52) | fn poll_open_bidi(
    method poll_open_send (line 75) | fn poll_open_send(
    method close (line 83) | fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
    type RecvStream (line 92) | type RecvStream = RecvStream;
    type OpenStreams (line 94) | type OpenStreams = OpenStreams;
    method poll_accept_recv (line 97) | fn poll_accept_recv(
    method poll_accept_bidi (line 105) | fn poll_accept_bidi(
    method opener (line 116) | fn opener(&self) -> Self::OpenStreams {
  type Target (line 26) | type Target = Arc<Connection>;
  method deref (line 28) | fn deref(&self) -> &Self::Target {
  type OpenStreams (line 122) | pub struct OpenStreams {
    method new (line 129) | fn new(conn: Arc<Connection>) -> Self {
    type BidiStream (line 150) | type BidiStream = BidiStream<B>;
    type SendStream (line 152) | type SendStream = SendStream<B>;
    method poll_open_bidi (line 155) | fn poll_open_bidi(
    method poll_open_send (line 163) | fn poll_open_send(
    method close (line 171) | fn close(&mut self, code: h3::error::Code, reason: &[u8]) {
  method clone (line 139) | fn clone(&self) -> Self {
  type BoxStream (line 177) | type BoxStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync>>;
  function sid_exceed_limit_error (line 179) | fn sid_exceed_limit_error() -> ConnectionErrorIncoming {
  type OpenBiStreams (line 186) | struct OpenBiStreams(
    method new (line 191) | fn new(conn: Arc<Connection>) -> Self {
    method poll_open (line 206) | fn poll_open<B>(
  type OpenUniStreams (line 221) | struct OpenUniStreams(BoxStream<Result<(StreamId, StreamWriter), Connect...
    method new (line 224) | fn new(conn: Arc<Connection>) -> Self {
    method poll_open (line 236) | fn poll_open<B>(
  type AcceptBiStreams (line 252) | struct AcceptBiStreams(
    method new (line 257) | fn new(conn: Arc<Connection>) -> Self {
    method poll_accept (line 269) | fn poll_accept<B>(
  type AcceptUniStreams (line 281) | struct AcceptUniStreams(BoxStream<Result<(StreamId, StreamReader), Conne...
    method new (line 284) | fn new(conn: Arc<Connection>) -> Self {
    method poll_accept (line 295) | fn poll_accept(

FILE: h3-shim/src/error.rs
  function convert_quic_error (line 7) | pub fn convert_quic_error(e: qbase::error::Error) -> ConnectionErrorInco...
  function convert_stream_io_error (line 18) | pub fn convert_stream_io_error(e: std::io::Error) -> StreamErrorIncoming {

FILE: h3-shim/src/streams.rs
  type SendStream (line 17) | pub struct SendStream<B> {
  function new (line 24) | pub fn new(sid: qbase::sid::StreamId, writer: StreamWriter) -> Self {
  function poll_ready (line 36) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Stream...
  function send_data (line 58) | fn send_data<T: Into<h3::quic::WriteBuf<B>>>(
  function poll_finish (line 68) | fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Strea...
  function reset (line 77) | fn reset(&mut self, reset_code: u64) {
  function send_id (line 83) | fn send_id(&self) -> h3::quic::StreamId {
  function poll_send (line 90) | fn poll_send<D: Buf>(
  type RecvStream (line 103) | pub struct RecvStream {
    method new (line 109) | pub(crate) fn new(sid: qbase::sid::StreamId, reader: StreamReader) -> ...
    type Buf (line 119) | type Buf = bytes::Bytes;
    method poll_data (line 122) | fn poll_data(
    method stop_sending (line 141) | fn stop_sending(&mut self, error_code: u64) {
    method recv_id (line 146) | fn recv_id(&self) -> h3::quic::StreamId {
  type BidiStream (line 151) | pub struct BidiStream<B> {
  function new (line 157) | pub(crate) fn new(
  type Buf (line 169) | type Buf = bytes::Bytes;
  function poll_data (line 172) | fn poll_data(
  function stop_sending (line 180) | fn stop_sending(&mut self, error_code: u64) {
  function recv_id (line 185) | fn recv_id(&self) -> h3::quic::StreamId {
  function poll_ready (line 192) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Stream...
  function send_data (line 197) | fn send_data<T: Into<h3::quic::WriteBuf<B>>>(
  function poll_finish (line 205) | fn poll_finish(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Strea...
  function reset (line 210) | fn reset(&mut self, reset_code: u64) {
  function send_id (line 215) | fn send_id(&self) -> h3::quic::StreamId {
  function poll_send (line 222) | fn poll_send<D: Buf>(
  type SendStream (line 232) | type SendStream = SendStream<B>;
  type RecvStream (line 234) | type RecvStream = RecvStream;
    method new (line 109) | pub(crate) fn new(sid: qbase::sid::StreamId, reader: StreamReader) -> ...
    type Buf (line 119) | type Buf = bytes::Bytes;
    method poll_data (line 122) | fn poll_data(
    method stop_sending (line 141) | fn stop_sending(&mut self, error_code: u64) {
    method recv_id (line 146) | fn recv_id(&self) -> h3::quic::StreamId {
  function split (line 237) | fn split(self) -> (Self::SendStream, Self::RecvStream) {

FILE: qbase/src/cid.rs
  type GenUniqueCid (line 14) | pub trait GenUniqueCid {
    method gen_unique_cid (line 17) | fn gen_unique_cid(&self) -> ConnectionId;
  type RetireCid (line 20) | pub trait RetireCid {
    method retire_cid (line 22) | fn retire_cid(&self, cid: ConnectionId);
  type Registry (line 31) | pub struct Registry<LOCAL, REMOTE> {
  function new (line 40) | pub fn new(role: Role, origin_dcid: ConnectionId, local: LOCAL, remote: ...
  function role (line 49) | pub fn role(&self) -> Role {
  function origin_dcid (line 53) | pub fn origin_dcid(&self) -> ConnectionId {

FILE: qbase/src/cid/connection_id.rs
  constant MAX_CID_SIZE (line 10) | pub const MAX_CID_SIZE: usize = 20;
  type ConnectionId (line 23) | pub struct ConnectionId {
    method fmt (line 29) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 38) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 44) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from_slice (line 93) | pub fn from_slice(bytes: &[u8]) -> Self {
    method random_gen (line 105) | pub fn random_gen(len: usize) -> Self {
    method random_gen_with_mark (line 117) | pub fn random_gen_with_mark(len: usize, mark: u8, mask: u8) -> Self {
    method encoding_size (line 131) | pub fn encoding_size(&self) -> usize {
    method eq (line 145) | fn eq(&self, other: &ConnectionId) -> bool {
  function be_connection_id (line 56) | pub fn be_connection_id(input: &[u8]) -> IResult<&[u8], ConnectionId> {
  function be_connection_id_with_len (line 67) | pub fn be_connection_id_with_len(input: &[u8], len: usize) -> IResult<&[...
  type WriteConnectionId (line 79) | pub trait WriteConnectionId: bytes::BufMut {
    method put_connection_id (line 81) | fn put_connection_id(&mut self, cid: &ConnectionId);
    method put_connection_id (line 85) | fn put_connection_id(&mut self, cid: &ConnectionId) {
  type Target (line 137) | type Target = [u8];
  method deref (line 139) | fn deref(&self) -> &Self::Target {
  method hash (line 151) | fn hash<H: Hasher>(&self, state: &mut H) {
  function test_read_connection_id (line 162) | fn test_read_connection_id() {
  function test_cid_from_large_slice (line 180) | fn test_cid_from_large_slice() {
  function test_write_connection_id (line 185) | fn test_write_connection_id() {

FILE: qbase/src/cid/local_cid.rs
  type LocalCids (line 17) | struct LocalCids<ISSUED>
  function new (line 40) | fn new(scid: ConnectionId, issued_cids: ISSUED) -> Self {
  function initial_scid (line 63) | fn initial_scid(&self) -> Option<ConnectionId> {
  function set_limit (line 72) | fn set_limit(&mut self, active_cid_limit: u64) -> Result<(), Error> {
  function issue_new_cid (line 90) | fn issue_new_cid(&mut self) {
  function recv_retire_cid_frame (line 102) | fn recv_retire_cid_frame(&mut self, frame: RetireConnectionIdFrame) -> R...
  function clear (line 128) | fn clear(&mut self) {
  method drop (line 139) | fn drop(&mut self) {
  type ArcLocalCids (line 163) | pub struct ArcLocalCids<ISSUED>(Arc<Mutex<LocalCids<ISSUED>>>)
  function new (line 178) | pub fn new(scid: ConnectionId, issued_cids: ISSUED) -> Self {
  function initial_scid (line 220) | pub fn initial_scid(&self) -> Option<ConnectionId> {
  function clear (line 235) | pub fn clear(&self) {
  function set_limit (line 243) | pub fn set_limit(&self, active_cid_limit: u64) -> Result<(), Error> {
  type Output (line 252) | type Output = ();
  function recv_frame (line 256) | fn recv_frame(
  type IssuedCids (line 271) | struct IssuedCids {
    method frames (line 277) | fn frames(&self) -> MutexGuard<'_, Vec<NewConnectionIdFrame>> {
    method active_cids (line 281) | fn active_cids(&self) -> MutexGuard<'_, HashMap<ConnectionId, ResetTok...
    method send_frame (line 306) | fn send_frame<I: IntoIterator<Item = NewConnectionIdFrame>>(&self, ite...
  method gen_unique_cid (line 287) | fn gen_unique_cid(&self) -> ConnectionId {
  method retire_cid (line 300) | fn retire_cid(&self, cid: ConnectionId) {
  function test_issue_cid (line 312) | fn test_issue_cid() {
  function test_recv_retire_cid_frame (line 324) | fn test_recv_retire_cid_frame() {

FILE: qbase/src/cid/remote_cid.rs
  type RemoteCids (line 24) | struct RemoteCids<RETIRED>
  function new (line 56) | fn new(active_cid_limit: u64, retired_cids: RETIRED) -> Self {
  function apply_initial_dcid (line 69) | fn apply_initial_dcid(&mut self, initial_dcid: ConnectionId, dcid_cell: ...
  function recv_new_cid_frame (line 99) | fn recv_new_cid_frame(
  function arrange_idle_cid (line 134) | fn arrange_idle_cid(&mut self) {
  function retire_prior_to (line 169) | fn retire_prior_to(&mut self, tomb_seq: u64) {
  function apply_dcid (line 218) | fn apply_dcid(&mut self) -> ArcCidCell<RETIRED> {
  type ArcRemoteCids (line 236) | pub struct ArcRemoteCids<RETIRED>(Arc<Mutex<RemoteCids<RETIRED>>>)
  function new (line 249) | pub fn new(active_cid_limit: u64, retired_cids: RETIRED) -> Self {
  function apply_initial_dcid (line 269) | pub fn apply_initial_dcid(&self, initial_dcid: ConnectionId, dcid_cell: ...
  function apply_dcid (line 279) | pub fn apply_dcid(&self) -> ArcCidCell<RETIRED> {
  function latest_dcid (line 287) | pub fn latest_dcid(&self) -> Option<ConnectionId> {
  type Output (line 304) | type Output = Option<ResetToken>;
  function recv_frame (line 306) | fn recv_frame(&self, frame: NewConnectionIdFrame) -> Result<Self::Output...
  type CidCell (line 312) | struct CidCell<RETIRED>
  function assign (line 327) | fn assign(&mut self, seq: u64, cid: ConnectionId) {
  function borrow_cid (line 345) | fn borrow_cid(&mut self, tx_waker: ArcSendWaker) -> Result<Option<Connec...
  function renew (line 360) | fn renew(&mut self) {
  function retire (line 372) | fn retire(&mut self) {
  type ArcCidCell (line 392) | pub struct ArcCidCell<RETIRED>(Arc<Mutex<CidCell<RETIRED>>>)
  function new (line 405) | fn new(retired_cids: RETIRED) -> Self {
  function is_retired (line 415) | fn is_retired(&self) -> bool {
  function borrow_cid (line 424) | pub fn borrow_cid(
  function retire (line 438) | pub fn retire(&self) {
  type BorrowedCid (line 447) | pub struct BorrowedCid<'a, RETIRED>
  type Target (line 459) | type Target = ConnectionId;
  method deref (line 461) | fn deref(&self) -> &Self::Target {
  method drop (line 470) | fn drop(&mut self) {
  type RetiredCids (line 482) | struct RetiredCids(Arc<Mutex<Vec<RetireConnectionIdFrame>>>);
    method send_frame (line 485) | fn send_frame<I: IntoIterator<Item = RetireConnectionIdFrame>>(&self, ...
  function test_remote_cids (line 491) | fn test_remote_cids() {
  function test_retire_in_remote_cids (line 538) | fn test_retire_in_remote_cids() {
  function test_retire_without_apply (line 618) | fn test_retire_without_apply() {

FILE: qbase/src/error.rs
  type ErrorKind (line 17) | pub enum ErrorKind {
    type Error (line 114) | type Error = InvalidErrorKind;
    method try_from (line 116) | fn try_from(value: VarInt) -> Result<Self, Self::Error> {
  method fmt (line 79) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type InvalidErrorKind (line 111) | pub struct InvalidErrorKind(u64);
  method from (line 142) | fn from(value: ErrorKind) -> Self {
  type ErrorFrameType (line 167) | pub enum ErrorFrameType {
    method from (line 226) | fn from(value: FrameType) -> Self {
  type QuicError (line 178) | pub struct QuicError {
    method new (line 187) | pub fn new<T: Into<Cow<'static, str>>>(
    method with_default_fty (line 201) | pub fn with_default_fty<T: Into<Cow<'static, str>>>(kind: ErrorKind, r...
    method kind (line 210) | pub fn kind(&self) -> ErrorKind {
    method frame_type (line 215) | pub fn frame_type(&self) -> ErrorFrameType {
    method reason (line 220) | pub fn reason(&self) -> &str {
  method from (line 232) | fn from(val: ErrorFrameType) -> Self {
  type AppError (line 243) | pub struct AppError {
    method new (line 250) | pub fn new(error_code: VarInt, reason: impl Into<Cow<'static, str>>) -...
    method error_code (line 260) | pub fn error_code(&self) -> u64 {
    method reason (line 265) | pub fn reason(&self) -> &str {
  type Error (line 271) | pub enum Error {
    method kind (line 279) | pub fn kind(&self) -> ErrorKind {
    method frame_type (line 286) | pub fn frame_type(&self) -> ErrorFrameType {
    method from (line 316) | fn from(frame: ConnectionCloseFrame) -> Self {
  function from (line 295) | fn from(e: Error) -> Self {
  method from (line 301) | fn from(e: Error) -> Self {
  method from (line 310) | fn from(e: AppError) -> Self {
  function test_error_kind_display (line 337) | fn test_error_kind_display() {
  function test_error_kind_conversion (line 344) | fn test_error_kind_conversion() {
  function test_error_creation (line 372) | fn test_error_creation() {
  function test_error_conversion (line 382) | fn test_error_conversion() {

FILE: qbase/src/flow.rs
  type SendControler (line 22) | struct SendControler<TX> {
  function new (line 31) | fn new(initial_max_data: u64, broker: TX, tx_wakers: ArcSendWakers) -> S...
  function increase_limit (line 41) | fn increase_limit(&mut self, max_data: u64) {
  function avaliable (line 49) | fn avaliable(&self) -> u64 {
  function commit (line 53) | fn commit(&mut self, flow: u64)
  function return_back (line 68) | fn return_back(&mut self, flow: u64) {
  function revise_max_data (line 75) | fn revise_max_data(&mut self, zero_rtt_rejected: bool, max_data: u64) {
  type ArcSendControler (line 107) | pub struct ArcSendControler<TX>(Arc<Mutex<Result<SendControler<TX>, Erro...
  function new (line 118) | pub fn new(initial_max_data: u64, broker: TX, tx_wakers: ArcSendWakers) ...
  function increase_limit (line 126) | fn increase_limit(&self, max_data: u64) {
  function credit (line 143) | pub fn credit(&self, quota: usize) -> Result<Credit<'_, TX>, Error>
  function revise_max_data (line 160) | pub fn revise_max_data(&self, zero_rtt_rejected: bool, max_data: u64) {
  function on_error (line 168) | pub fn on_error(&self, error: &Error) {
  type Output (line 180) | type Output = ();
  function recv_frame (line 182) | fn recv_frame(&self, frame: MaxDataFrame) -> Result<Self::Output, Error> {
  type Credit (line 193) | pub struct Credit<'a, TX> {
  function available (line 200) | pub fn available(&self) -> usize {
  function post_sent (line 210) | pub fn post_sent(&mut self, amount: usize) {
  method drop (line 216) | fn drop(&mut self) {
  type RecvController (line 225) | struct RecvController<TX> {
  function new (line 234) | fn new(initial_max_data: u64, broker: TX) -> Self {
  function on_new_rcvd (line 253) | fn on_new_rcvd(&mut self, frame_type: FrameType, amount: usize) -> Resul...
  type ArcRecvController (line 293) | pub struct ArcRecvController<TX>(Arc<Mutex<RecvController<TX>>>);
  function new (line 297) | pub fn new(initial_max_data: u64, broker: TX) -> Self {
  function on_new_rcvd (line 314) | pub fn on_new_rcvd(&self, frame_type: FrameType, amount: usize) -> Resul...
  type Output (line 325) | type Output = ();
  function recv_frame (line 327) | fn recv_frame(&self, _frame: DataBlockedFrame) -> Result<Self::Output, E...
  type FlowController (line 336) | pub struct FlowController<TX> {
  function new (line 347) | pub fn new(
  function reset_send_window (line 363) | pub fn reset_send_window(&self, snd_wnd: u64) {
  function send_limit (line 370) | pub fn send_limit(&self, quota: usize) -> Result<Credit<'_, TX>, Error>
  function on_conn_error (line 382) | pub fn on_conn_error(&self, error: &Error) {
  function on_new_rcvd (line 394) | pub fn on_new_rcvd(&self, frame_type: FrameType, amount: usize) -> Resul...
  type SendControllerBroker (line 406) | struct SendControllerBroker(Arc<Mutex<Vec<DataBlockedFrame>>>);
    method send_frame (line 409) | fn send_frame<I: IntoIterator<Item = DataBlockedFrame>>(&self, iter: I) {
  function test_send_controler (line 415) | fn test_send_controler() {
  type RecvControllerBroker (line 451) | struct RecvControllerBroker(Arc<Mutex<Vec<MaxDataFrame>>>);
    method send_frame (line 454) | fn send_frame<I: IntoIterator<Item = MaxDataFrame>>(&self, iter: I) {
  function test_recv_controller (line 460) | fn test_recv_controller() {

FILE: qbase/src/frame.rs
  type GetFrameType (line 75) | pub trait GetFrameType {
    method frame_type (line 77) | fn frame_type(&self) -> FrameType;
    method frame_type (line 580) | fn frame_type(&self) -> FrameType {
  type EncodeSize (line 81) | pub trait EncodeSize {
    method max_encoding_size (line 90) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 95) | fn encoding_size(&self) -> usize {
    method max_encoding_size (line 617) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 645) | fn encoding_size(&self) -> usize {
  type Spec (line 105) | pub enum Spec {
  type ContainSpec (line 134) | pub trait ContainSpec {
    method contain (line 135) | fn contain(&self, spec: Spec) -> bool;
    method contain (line 140) | fn contain(&self, spec: Spec) -> bool {
  type FrameType (line 151) | pub enum FrameType {
    type Error (line 301) | type Error = Error;
    method try_from (line 303) | fn try_from(frame_type: VarInt) -> Result<Self, Self::Error> {
  type FrameFeature (line 207) | pub trait FrameFeature {
    method belongs_to (line 209) | fn belongs_to(&self, packet_type: Type) -> bool;
    method specs (line 211) | fn specs(&self) -> u8;
    method belongs_to (line 215) | fn belongs_to(&self, packet_type: Type) -> bool {
    method specs (line 219) | fn specs(&self) -> u8 {
    method belongs_to (line 225) | fn belongs_to(&self, packet_type: Type) -> bool {
    method specs (line 276) | fn specs(&self) -> u8 {
  method from (line 350) | fn from(frame_type: FrameType) -> Self {
  function be_frame_type (line 393) | pub fn be_frame_type(input: &[u8]) -> nom::IResult<&[u8], FrameType, Err...
  type StreamCtlFrame (line 406) | pub enum StreamCtlFrame {
  type ReliableFrame (line 424) | pub enum ReliableFrame {
    type Error (line 540) | type Error = &'f Frame<D>;
    method try_from (line 543) | fn try_from(frame: &'f Frame<D>) -> Result<Self, Self::Error> {
  type Frame (line 453) | pub enum Frame<D = Bytes> {
  function from (line 500) | fn from(frame: ReliableFrame) -> Self {
  type Error (line 528) | type Error = &'f Frame<D>;
  method try_from (line 531) | fn try_from(frame: &'f Frame<D>) -> Result<Self, Self::Error> {
  type FrameReader (line 674) | pub struct FrameReader {
    method new (line 683) | pub fn new(payload: Bytes, packet_type: Type) -> Self {
  type Item (line 692) | type Item = Result<(Frame, FrameType), Error>;
  method next (line 694) | fn next(&mut self) -> Option<Self::Item> {
  method put_frame (line 710) | fn put_frame(&mut self, frame: &StreamCtlFrame) {
  method put_frame (line 723) | fn put_frame(&mut self, frame: &ReliableFrame) {
  function test_frame_type_conversion (line 761) | fn test_frame_type_conversion() {
  function test_frame_type_specs (line 780) | fn test_frame_type_specs() {
  function test_frame_type_belongs_to (line 796) | fn test_frame_type_belongs_to() {
  function test_frame_reader (line 805) | fn test_frame_reader() {
  function test_invalid_frame_type (line 828) | fn test_invalid_frame_type() {
  function test_frame_reader_parses_add_address_frame (line 833) | fn test_frame_reader_parses_add_address_frame() {
  function test_frame_reader_rejects_add_address_frame_in_non_data_packets (line 855) | fn test_frame_reader_rejects_add_address_frame_in_non_data_packets() {
  function test_manual_unknown_custom_frame_fallback (line 879) | fn test_manual_unknown_custom_frame_fallback() {
  function test_frame_reader_stops_at_unknown_custom_frame (line 960) | fn test_frame_reader_stops_at_unknown_custom_frame() {

FILE: qbase/src/frame/ack.rs
  type Ecn (line 12) | pub enum Ecn {
    method from (line 29) | fn from(value: u8) -> Self {
  function from (line 20) | fn from(ecn: Ecn) -> u8 {
  type AckFrame (line 60) | pub struct AckFrame {
    method frame_type (line 69) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 79) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 83) | fn encoding_size(&self) -> usize {
    method new (line 105) | pub fn new(
    method largest (line 122) | pub fn largest(&self) -> u64 {
    method delay (line 127) | pub fn delay(&self) -> u64 {
    method first_range (line 132) | pub fn first_range(&self) -> u64 {
    method ranges (line 137) | pub fn ranges(&self) -> &Vec<(VarInt, VarInt)> {
    method ecn (line 142) | pub fn ecn(&self) -> Option<EcnCounts> {
    method set_ecn (line 147) | pub fn set_ecn(&mut self, ecn: EcnCounts) {
    method take_ecn (line 152) | pub fn take_ecn(&mut self) -> Option<EcnCounts> {
    method iter (line 158) | pub fn iter(&self) -> impl Iterator<Item = RangeInclusive<u64>> + '_ {
  type EcnCounts (line 179) | pub struct EcnCounts {
    method new (line 187) | pub fn new(ect0: VarInt, ect1: VarInt, ce: VarInt) -> Self {
    method ect0 (line 192) | pub fn ect0(&self) -> u64 {
    method ect1 (line 197) | pub fn ect1(&self) -> u64 {
    method ce (line 202) | pub fn ce(&self) -> u64 {
    method encoding_size (line 207) | fn encoding_size(&self) -> usize {
  function ack_frame_with_ecn (line 214) | pub fn ack_frame_with_ecn(ecn: Ecn) -> impl Fn(&[u8]) -> nom::IResult<&[...
  function be_ecn_counts (line 250) | pub(super) fn be_ecn_counts(input: &[u8]) -> nom::IResult<&[u8], EcnCoun...
  method put_frame (line 258) | fn put_frame(&mut self, frame: &AckFrame) {
  function test_ack_frame (line 290) | fn test_ack_frame() {
  function test_read_ecn_count (line 315) | fn test_read_ecn_count() {
  function test_read_ack_frame (line 330) | fn test_read_ack_frame() {
  function test_write_ack_frame (line 353) | fn test_write_ack_frame() {
  function test_ack_frame_into_iter (line 378) | fn test_ack_frame_into_iter() {

FILE: qbase/src/frame/add_address.rs
  type AddAddressFrame (line 24) | pub struct AddAddressFrame {
    method new (line 88) | pub fn new(seq_num: u32, address: SocketAddr, tire: u32, nat_type: Nat...
    method seq_num (line 97) | pub fn seq_num(&self) -> u32 {
    method tire (line 101) | pub fn tire(&self) -> u32 {
    method nat_type (line 105) | pub fn nat_type(&self) -> NatType {
  function be_add_address_frame (line 32) | pub(crate) fn be_add_address_frame(
  method frame_type (line 59) | fn frame_type(&self) -> super::FrameType {
  method max_encoding_size (line 65) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 74) | fn encoding_size(&self) -> usize {
  method put_frame (line 111) | fn put_frame(&mut self, frame: &AddAddressFrame) {
  function test_add_address_frame (line 130) | fn test_add_address_frame() {

FILE: qbase/src/frame/connection_close.rs
  type Layer (line 15) | pub enum Layer {
    method from (line 32) | fn from(value: u8) -> Self {
  function from (line 23) | fn from(layer: Layer) -> u8 {
  type AppCloseFrame (line 40) | pub struct AppCloseFrame {
    method error_code (line 47) | pub fn error_code(&self) -> u64 {
    method reason (line 52) | pub fn reason(&self) -> &str {
    method conceal (line 63) | pub fn conceal(&self) -> QuicCloseFrame {
  type QuicCloseFrame (line 83) | pub struct QuicCloseFrame {
    method from (line 73) | fn from(_: AppCloseFrame) -> Self {
    method error_kind (line 91) | pub fn error_kind(&self) -> ErrorKind {
    method frame_type (line 96) | pub fn frame_type(&self) -> ErrorFrameType {
    method reason (line 101) | pub fn reason(&self) -> &str {
  type ConnectionCloseFrame (line 121) | pub enum ConnectionCloseFrame {
    method frame_type (line 127) | fn frame_type(&self) -> FrameType {
    method max_encoding_size (line 136) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 144) | fn encoding_size(&self) -> usize {
    method new_quic (line 164) | pub fn new_quic(
    method new_app (line 177) | pub fn new_app(error_code: VarInt, reason: impl Into<Cow<'static, str>...
  function be_app_close_frame (line 185) | fn be_app_close_frame(input: &[u8]) -> nom::IResult<&[u8], AppCloseFrame> {
  function be_quic_close_frame (line 199) | fn be_quic_close_frame(input: &[u8]) -> nom::IResult<&[u8], QuicCloseFra...
  function connection_close_frame_at_layer (line 225) | pub fn connection_close_frame_at_layer(
  method put_frame (line 238) | fn put_frame(&mut self, frame: &ConnectionCloseFrame) {
  function test_connection_close_frame (line 273) | fn test_connection_close_frame() {
  function test_read_connection_close_frame (line 281) | fn test_read_connection_close_frame() {
  function test_write_connection_close_frame (line 306) | fn test_write_connection_close_frame() {

FILE: qbase/src/frame/crypto.rs
  type CryptoFrame (line 25) | pub struct CryptoFrame {
    method frame_type (line 31) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 37) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 41) | fn encoding_size(&self) -> usize {
    method new (line 48) | pub fn new(offset: VarInt, length: VarInt) -> Self {
    method offset (line 53) | pub fn offset(&self) -> u64 {
    method len (line 58) | pub fn len(&self) -> u64 {
    method estimate_max_capacity (line 68) | pub fn estimate_max_capacity(capacity: usize, offset: u64) -> Option<u...
    method range (line 95) | pub fn range(&self) -> Range<u64> {
  function be_crypto_frame (line 104) | pub fn be_crypto_frame(input: &[u8]) -> nom::IResult<&[u8], CryptoFrame> {
  method put_data_frame (line 120) | fn put_data_frame(&mut self, frame: &CryptoFrame, data: &D) {
  function test_crypto_frame (line 141) | fn test_crypto_frame() {
  function test_read_crypto_frame (line 152) | fn test_read_crypto_frame() {
  function test_write_crypto_frame (line 164) | fn test_write_crypto_frame() {
  function test_encoding_capacity_estimate (line 176) | fn test_encoding_capacity_estimate() {
  function test_encoding_with_offset_exceeded (line 193) | fn test_encoding_with_offset_exceeded() {
  function test_encoding_with_length_too_large (line 199) | fn test_encoding_with_length_too_large() {

FILE: qbase/src/frame/data_blocked.rs
  type DataBlockedFrame (line 18) | pub struct DataBlockedFrame {
    method frame_type (line 23) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 29) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 33) | fn encoding_size(&self) -> usize {
    method new (line 40) | pub fn new(limit: VarInt) -> Self {
    method limit (line 45) | pub fn limit(&self) -> u64 {
  function be_data_blocked_frame (line 52) | pub fn be_data_blocked_frame(input: &[u8]) -> nom::IResult<&[u8], DataBl...
  method put_frame (line 58) | fn put_frame(&mut self, frame: &DataBlockedFrame) {
  function test_data_blocked_frame (line 73) | fn test_data_blocked_frame() {
  function test_read_data_blocked_frame (line 81) | fn test_read_data_blocked_frame() {
  function test_write_data_blocked_frame (line 89) | fn test_write_data_blocked_frame() {

FILE: qbase/src/frame/datagram.rs
  type DatagramFrame (line 24) | pub struct DatagramFrame {
    method new (line 31) | pub fn new(encode_len: bool, len: VarInt) -> Self {
    method encode_len (line 36) | pub fn encode_len(&self) -> bool {
    method len (line 41) | pub fn len(&self) -> VarInt {
    method max_encoding_size (line 53) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 57) | fn encoding_size(&self) -> usize {
  method frame_type (line 47) | fn frame_type(&self) -> FrameType {
  function datagram_frame_with_flag (line 68) | pub fn datagram_frame_with_flag(flag: u8) -> impl FnOnce(&[u8]) -> IResu...
  method put_data_frame (line 93) | fn put_data_frame(&mut self, frame: &DatagramFrame, data: &D) {
  function test_datagram_frame (line 108) | fn test_datagram_frame() {
  function test_datagram_frame_with_flag (line 119) | fn test_datagram_frame_with_flag() {
  function test_datagram_frame_with_flag_no_length (line 131) | fn test_datagram_frame_with_flag_no_length() {
  function test_put_datagram_frame_with_length (line 143) | fn test_put_datagram_frame_with_length() {
  function test_put_datagram_frame_no_length (line 154) | fn test_put_datagram_frame_no_length() {

FILE: qbase/src/frame/error.rs
  type Error (line 13) | pub enum Error {
    method from (line 55) | fn from(error: nom::Err<Error>) -> Self {
    method from_error_kind (line 66) | fn from_error_kind(_input: &[u8], _kind: NomErrorKind) -> Self {
    method append (line 71) | fn append(_input: &[u8], _kind: NomErrorKind, source: Self) -> Self {
  method from (line 29) | fn from(e: Error) -> Self {
  function test_error_conversion_to_transport_error (line 92) | fn test_error_conversion_to_transport_error() {
  function test_nom_error_conversion (line 124) | fn test_nom_error_conversion() {
  function test_parse_error_impl (line 136) | fn test_parse_error_impl() {
  function test_parse_error_unreachable (line 144) | fn test_parse_error_unreachable() {
  function test_error_display (line 149) | fn test_error_display() {

FILE: qbase/src/frame/handshake_done.rs
  type HandshakeDoneFrame (line 14) | pub struct HandshakeDoneFrame;
    method frame_type (line 17) | fn frame_type(&self) -> super::FrameType {
  function be_handshake_done_frame (line 27) | pub fn be_handshake_done_frame(input: &[u8]) -> nom::IResult<&[u8], Hand...
  method put_frame (line 32) | fn put_frame(&mut self, frame: &HandshakeDoneFrame) {
  function test_handshake_done_frame (line 48) | fn test_handshake_done_frame() {
  function test_read_handshake_done_frame (line 55) | fn test_read_handshake_done_frame() {
  function test_write_handshake_done_frame (line 76) | fn test_write_handshake_done_frame() {

FILE: qbase/src/frame/io.rs
  function complete_frame (line 29) | fn complete_frame(
  function be_frame (line 128) | pub fn be_frame(raw: &Bytes, packet_type: Type) -> Result<(usize, Frame,...
  type WriteFrame (line 155) | pub trait WriteFrame<F>: bytes::BufMut {
    method put_frame (line 157) | fn put_frame(&mut self, frame: &F);
  method put_frame (line 166) | fn put_frame(&mut self, frame: &Frame<D>) {
  type WriteDataFrame (line 200) | pub trait WriteDataFrame<F, D: ContinuousData>: bytes::BufMut {
    method put_data_frame (line 202) | fn put_data_frame(&mut self, frame: &F, data: &D);
  type WriteFrameType (line 206) | pub trait WriteFrameType: bytes::BufMut {
    method put_frame_type (line 208) | fn put_frame_type(&mut self, frame_type: FrameType);
    method put_frame_type (line 212) | fn put_frame_type(&mut self, frame_type: FrameType) {
  type SendFrame (line 224) | pub trait SendFrame<T> {
    method send_frame (line 226) | fn send_frame<I: IntoIterator<Item = T>>(&self, iter: I);
  type ReceiveFrame (line 234) | pub trait ReceiveFrame<T> {
    method recv_frame (line 238) | fn recv_frame(&self, frame: T) -> Result<Self::Output, crate::error::E...
  type Output (line 242) | type Output = Result<Option<F>, ResetError>;
  method poll (line 244) | fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Outpu...
  type Output (line 269) | type Output = ();
  function recv_frame (line 271) | fn recv_frame(&self, frame: F) -> Result<Self::Output, crate::error::Err...

FILE: qbase/src/frame/max_data.rs
  type MaxDataFrame (line 18) | pub struct MaxDataFrame {
    method frame_type (line 23) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 29) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 33) | fn encoding_size(&self) -> usize {
    method new (line 40) | pub fn new(max_data: VarInt) -> Self {
    method max_data (line 45) | pub fn max_data(&self) -> u64 {
  function be_max_data_frame (line 52) | pub fn be_max_data_frame(input: &[u8]) -> nom::IResult<&[u8], MaxDataFra...
  method put_frame (line 58) | fn put_frame(&mut self, frame: &MaxDataFrame) {
  function test_max_data_frame (line 76) | fn test_max_data_frame() {
  function test_read_max_data_frame (line 84) | fn test_read_max_data_frame() {
  function test_write_max_data_frame (line 105) | fn test_write_max_data_frame() {

FILE: qbase/src/frame/max_stream_data.rs
  type MaxStreamDataFrame (line 20) | pub struct MaxStreamDataFrame {
    method new (line 27) | pub fn new(stream_id: StreamId, max_stream_data: VarInt) -> Self {
    method stream_id (line 35) | pub fn stream_id(&self) -> StreamId {
    method max_stream_data (line 40) | pub fn max_stream_data(&self) -> u64 {
    method frame_type (line 46) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 52) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 56) | fn encoding_size(&self) -> usize {
  function be_max_stream_data_frame (line 63) | pub fn be_max_stream_data_frame(input: &[u8]) -> nom::IResult<&[u8], Max...
  method put_frame (line 76) | fn put_frame(&mut self, frame: &MaxStreamDataFrame) {
  function test_max_stream_data_frame (line 95) | fn test_max_stream_data_frame() {
  function test_read_max_stream_data_frame (line 106) | fn test_read_max_stream_data_frame() {
  function test_write_max_stream_data_frame (line 115) | fn test_write_max_stream_data_frame() {

FILE: qbase/src/frame/max_streams.rs
  type MaxStreamsFrame (line 19) | pub enum MaxStreamsFrame {
    method with (line 25) | pub fn with(dir: Dir, max_streams: VarInt) -> Self {
    method frame_type (line 34) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 43) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 47) | fn encoding_size(&self) -> usize {
  function max_streams_frame_with_dir (line 57) | pub fn max_streams_frame_with_dir(
  method put_frame (line 80) | fn put_frame(&mut self, frame: &MaxStreamsFrame) {
  function test_max_streams_frame (line 109) | fn test_max_streams_frame() {
  function test_read_max_streams_frame (line 122) | fn test_read_max_streams_frame() {
  function test_read_too_large_max_streams_frame (line 153) | fn test_read_too_large_max_streams_frame() {
  function test_write_max_streams_frame (line 175) | fn test_write_max_streams_frame() {

FILE: qbase/src/frame/new_connection_id.rs
  type NewConnectionIdFrame (line 24) | pub struct NewConnectionIdFrame {
    method new (line 33) | pub fn new(cid: ConnectionId, sequence: VarInt, retire_prior_to: VarIn...
    method sequence (line 44) | pub fn sequence(&self) -> u64 {
    method retire_prior_to (line 49) | pub fn retire_prior_to(&self) -> u64 {
    method connection_id (line 54) | pub fn connection_id(&self) -> &ConnectionId {
    method reset_token (line 59) | pub fn reset_token(&self) -> &ResetToken {
    method frame_type (line 65) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 71) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 75) | fn encoding_size(&self) -> usize {
  function be_new_connection_id_frame (line 86) | pub fn be_new_connection_id_frame(input: &[u8]) -> nom::IResult<&[u8], N...
  method put_frame (line 122) | fn put_frame(&mut self, frame: &NewConnectionIdFrame) {
  function test_new_connection_id_frame (line 142) | fn test_new_connection_id_frame() {
  function test_frame_parsing (line 164) | fn test_frame_parsing() {
  function test_invalid_retire_prior_to (line 186) | fn test_invalid_retire_prior_to() {
  function test_zero_length_connection_id (line 196) | fn test_zero_length_connection_id() {

FILE: qbase/src/frame/new_token.rs
  type NewTokenFrame (line 20) | pub struct NewTokenFrame {
    method frame_type (line 26) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 32) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 37) | fn encoding_size(&self) -> usize {
    method new (line 44) | pub fn new(token: Vec<u8>) -> Self {
    method from_slice (line 49) | pub fn from_slice(token: &[u8]) -> Self {
    method token (line 56) | pub fn token(&self) -> &[u8] {
  function be_new_token_frame (line 63) | pub fn be_new_token_frame(input: &[u8]) -> nom::IResult<&[u8], NewTokenF...
  method put_frame (line 76) | fn put_frame(&mut self, frame: &NewTokenFrame) {
  function test_new_token_frame (line 90) | fn test_new_token_frame() {
  function test_read_new_token_frame (line 98) | fn test_read_new_token_frame() {
  function test_write_new_token_frame (line 107) | fn test_write_new_token_frame() {

FILE: qbase/src/frame/padding.rs
  type PaddingFrame (line 13) | pub struct PaddingFrame;
    method frame_type (line 16) | fn frame_type(&self) -> super::FrameType {
  function be_padding_frame (line 26) | pub fn be_padding_frame(input: &[u8]) -> nom::IResult<&[u8], PaddingFram...
  method put_frame (line 31) | fn put_frame(&mut self, frame: &PaddingFrame) {
  function test_padding_frame (line 48) | fn test_padding_frame() {
  function test_read_padding_frame (line 55) | fn test_read_padding_frame() {
  function test_write_padding_frame (line 75) | fn test_write_padding_frame() {

FILE: qbase/src/frame/path_challenge.rs
  type PathChallengeFrame (line 17) | pub struct PathChallengeFrame {
    method from_slice (line 23) | pub fn from_slice(data: &[u8]) -> Self {
    method random (line 29) | pub fn random() -> Self {
    method frame_type (line 38) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 44) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 48) | fn encoding_size(&self) -> usize {
  function be_path_challenge_frame (line 55) | pub fn be_path_challenge_frame(input: &[u8]) -> nom::IResult<&[u8], Path...
  method put_frame (line 62) | fn put_frame(&mut self, frame: &PathChallengeFrame) {
  function test_path_challenge_frame (line 81) | fn test_path_challenge_frame() {
  function test_read_path_challenge_frame (line 91) | fn test_read_path_challenge_frame() {
  function test_write_path_challenge_frame (line 115) | fn test_write_path_challenge_frame() {

FILE: qbase/src/frame/path_response.rs
  type PathResponseFrame (line 18) | pub struct PathResponseFrame {
    method from_slice (line 24) | fn from_slice(data: &[u8]) -> Self {
    method from (line 33) | fn from(challenge: super::PathChallengeFrame) -> Self {
    method frame_type (line 39) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 45) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 49) | fn encoding_size(&self) -> usize {
  function be_path_response_frame (line 56) | pub fn be_path_response_frame(input: &[u8]) -> nom::IResult<&[u8], PathR...
  method put_frame (line 62) | fn put_frame(&mut self, frame: &PathResponseFrame) {
  function test_path_response_frame (line 77) | fn test_path_response_frame() {
  function test_read_path_response_frame (line 86) | fn test_read_path_response_frame() {
  function test_write_path_response_frame (line 114) | fn test_write_path_response_frame() {

FILE: qbase/src/frame/ping.rs
  type PingFrame (line 13) | pub struct PingFrame;
    method frame_type (line 16) | fn frame_type(&self) -> super::FrameType {
  function be_ping_frame (line 26) | pub fn be_ping_frame(input: &[u8]) -> nom::IResult<&[u8], PingFrame> {
  method put_frame (line 31) | fn put_frame(&mut self, frame: &PingFrame) {
  function test_ping_frame (line 47) | fn test_ping_frame() {
  function test_read_ping_frame (line 54) | fn test_read_ping_frame() {
  function test_write_ping_frame (line 75) | fn test_write_ping_frame() {

FILE: qbase/src/frame/punch_done.rs
  type PunchDoneFrame (line 17) | pub struct PunchDoneFrame {
    method new (line 24) | pub fn new(local_seq: u32, remote_seq: u32, probe_id: u32) -> Self {
    method local_seq (line 32) | pub fn local_seq(&self) -> u32 {
    method remote_seq (line 36) | pub fn remote_seq(&self) -> u32 {
    method probe_id (line 40) | pub fn probe_id(&self) -> u32 {
    method respond_to (line 46) | pub fn respond_to(hello: &PunchHelloFrame) -> Self {
  method frame_type (line 52) | fn frame_type(&self) -> super::FrameType {
  method max_encoding_size (line 58) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 62) | fn encoding_size(&self) -> usize {
  method put_frame (line 71) | fn put_frame(&mut self, frame: &PunchDoneFrame) {
  function be_punch_done_frame (line 79) | pub(crate) fn be_punch_done_frame(input: &[u8]) -> nom::IResult<&[u8], P...

FILE: qbase/src/frame/punch_hello.rs
  type PunchHelloFrame (line 14) | pub struct PunchHelloFrame {
    method new (line 21) | pub fn new(local_seq: u32, remote_seq: u32, probe_id: u32) -> Self {
    method local_seq (line 29) | pub fn local_seq(&self) -> u32 {
    method remote_seq (line 33) | pub fn remote_seq(&self) -> u32 {
    method probe_id (line 37) | pub fn probe_id(&self) -> u32 {
  method frame_type (line 43) | fn frame_type(&self) -> super::FrameType {
  method max_encoding_size (line 49) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 53) | fn encoding_size(&self) -> usize {
  method put_frame (line 62) | fn put_frame(&mut self, frame: &PunchHelloFrame) {
  function be_punch_hello_frame (line 70) | pub(crate) fn be_punch_hello_frame(input: &[u8]) -> nom::IResult<&[u8], ...

FILE: qbase/src/frame/punch_me_now.rs
  type PunchMeNowFrame (line 29) | pub struct PunchMeNowFrame {
    method new (line 88) | pub fn new(
    method local_seq (line 104) | pub fn local_seq(&self) -> u32 {
    method remote_seq (line 108) | pub fn remote_seq(&self) -> u32 {
    method nat_type (line 112) | pub fn nat_type(&self) -> NatType {
    method set_addr (line 116) | pub fn set_addr(&mut self, addr: SocketAddr) {
    method address (line 120) | pub fn address(&self) -> SocketAddr {
    method tire (line 124) | pub fn tire(&self) -> u32 {
  function be_punch_me_now_frame (line 38) | pub(crate) fn be_punch_me_now_frame(
  method frame_type (line 67) | fn frame_type(&self) -> super::FrameType {
  method max_encoding_size (line 73) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 77) | fn encoding_size(&self) -> usize {
  method put_frame (line 130) | fn put_frame(&mut self, frame: &PunchMeNowFrame) {
  function test_punch_me_now_frame (line 152) | fn test_punch_me_now_frame() {

FILE: qbase/src/frame/remove_address.rs
  type RemoveAddressFrame (line 14) | pub struct RemoveAddressFrame {
  function be_remove_address_frame (line 19) | pub(crate) fn be_remove_address_frame(input: &[u8]) -> nom::IResult<&[u8...
  method frame_type (line 30) | fn frame_type(&self) -> super::FrameType {
  method max_encoding_size (line 36) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 40) | fn encoding_size(&self) -> usize {
  method put_frame (line 46) | fn put_frame(&mut self, frame: &RemoveAddressFrame) {
  function test_remove_address_frame (line 60) | fn test_remove_address_frame() {

FILE: qbase/src/frame/reset_stream.rs
  type ResetStreamFrame (line 23) | pub struct ResetStreamFrame {
    method frame_type (line 30) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 36) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 40) | fn encoding_size(&self) -> usize {
    method new (line 49) | pub fn new(stream_id: StreamId, app_error_code: VarInt, final_size: Va...
    method stream_id (line 58) | pub fn stream_id(&self) -> StreamId {
    method app_error_code (line 63) | pub fn app_error_code(&self) -> u64 {
    method final_size (line 68) | pub fn final_size(&self) -> u64 {
  function be_reset_stream_frame (line 75) | pub fn be_reset_stream_frame(input: &[u8]) -> nom::IResult<&[u8], ResetS...
  method put_frame (line 89) | fn put_frame(&mut self, frame: &ResetStreamFrame) {
  type ResetStreamError (line 99) | pub struct ResetStreamError {
    method new (line 105) | pub fn new(app_error_code: VarInt, final_size: VarInt) -> Self {
    method error_code (line 112) | pub fn error_code(&self) -> u64 {
    method combine (line 116) | pub fn combine(self, sid: StreamId) -> ResetStreamFrame {
    method from (line 126) | fn from(frame: &ResetStreamFrame) -> Self {
  function test_reset_stream_frame (line 148) | fn test_reset_stream_frame() {
  function test_read_reset_stream_frame (line 169) | fn test_read_reset_stream_frame() {
  function test_write_reset_stream_frame (line 194) | fn test_write_reset_stream_frame() {

FILE: qbase/src/frame/retire_connection_id.rs
  type RetireConnectionIdFrame (line 18) | pub struct RetireConnectionIdFrame {
    method frame_type (line 23) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 29) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 33) | fn encoding_size(&self) -> usize {
    method new (line 40) | pub fn new(sequence: VarInt) -> Self {
    method sequence (line 45) | pub fn sequence(&self) -> u64 {
  function be_retire_connection_id_frame (line 52) | pub fn be_retire_connection_id_frame(input: &[u8]) -> nom::IResult<&[u8]...
  method put_frame (line 58) | fn put_frame(&mut self, frame: &RetireConnectionIdFrame) {
  function test_retire_connection_id_frame (line 76) | fn test_retire_connection_id_frame() {
  function test_read_retire_connection_id_frame (line 85) | fn test_read_retire_connection_id_frame() {
  function test_write_retire_connection_id_frame (line 96) | fn test_write_retire_connection_id_frame() {

FILE: qbase/src/frame/stop_sending.rs
  type StopSendingFrame (line 20) | pub struct StopSendingFrame {
    method new (line 27) | pub fn new(stream_id: StreamId, app_err_code: VarInt) -> Self {
    method stream_id (line 35) | pub fn stream_id(&self) -> StreamId {
    method app_err_code (line 40) | pub fn app_err_code(&self) -> u64 {
    method reset_stream (line 45) | pub fn reset_stream(&self, final_size: VarInt) -> super::ResetStreamFr...
    method frame_type (line 51) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 57) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 61) | fn encoding_size(&self) -> usize {
  function be_stop_sending_frame (line 68) | pub fn be_stop_sending_frame(input: &[u8]) -> nom::IResult<&[u8], StopSe...
  method put_frame (line 80) | fn put_frame(&mut self, frame: &StopSendingFrame) {
  function test_stop_sending_frame (line 99) | fn test_stop_sending_frame() {
  function test_parse_stop_sending_frame (line 110) | fn test_parse_stop_sending_frame() {
  function test_write_stop_sending_frame (line 132) | fn test_write_stop_sending_frame() {

FILE: qbase/src/frame/stream.rs
  type Offset (line 13) | pub enum Offset {
    method from (line 30) | fn from(value: u64) -> Self {
  function from (line 21) | fn from(offset: Offset) -> u8 {
  type Len (line 40) | pub enum Len {
    method from (line 57) | fn from(value: u64) -> Self {
  function from (line 48) | fn from(length: Len) -> u8 {
  type Fin (line 67) | pub enum Fin {
    method from (line 84) | fn from(value: u64) -> Self {
  function from (line 75) | fn from(fin: Fin) -> u8 {
  type StreamFrame (line 112) | pub struct StreamFrame {
    method max_encoding_size (line 134) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 138) | fn encoding_size(&self) -> usize {
    method new (line 176) | pub fn new(id: StreamId, offset: u64, length: usize) -> Self {
    method stream_id (line 189) | pub fn stream_id(&self) -> StreamId {
    method is_fin (line 194) | pub fn is_fin(&self) -> bool {
    method offset (line 199) | pub fn offset(&self) -> u64 {
    method len (line 204) | pub fn len(&self) -> usize {
    method is_empty (line 209) | pub fn is_empty(&self) -> bool {
    method range (line 214) | pub fn range(&self) -> Range<u64> {
    method set_eos_flag (line 219) | pub fn set_eos_flag(&mut self, is_eos: bool) {
    method set_len_bit (line 228) | pub fn set_len_bit(&mut self, len_bit: Len) {
    method encoding_strategy (line 242) | pub fn encoding_strategy(&self, capacity: usize) -> EncodingStrategy {
    method estimate_max_capacity (line 280) | pub fn estimate_max_capacity(capacity: usize, sid: StreamId, offset: u...
  constant STREAM_FRAME_MAX_ENCODING_SIZE (line 120) | pub const STREAM_FRAME_MAX_ENCODING_SIZE: usize = 1 + 8 + 8 + 8;
  method frame_type (line 123) | fn frame_type(&self) -> super::FrameType {
  type EncodingStrategy (line 157) | pub struct EncodingStrategy {
    method len_bit (line 164) | pub fn len_bit(&self) -> Len {
    method pre_padding (line 169) | pub fn pre_padding(&self) -> usize {
  function stream_frame_with_flag (line 296) | pub fn stream_frame_with_flag(
  method put_data_frame (line 338) | fn put_data_frame(&mut self, frame: &StreamFrame, data: &D) {
  function test_stream_frame (line 365) | fn test_stream_frame() {
  function test_read_stream_frame (line 382) | fn test_read_stream_frame() {
  function test_read_last_stream_frame (line 416) | fn test_read_last_stream_frame() {
  function test_write_initial_stream_frame (line 450) | fn test_write_initial_stream_frame() {
  function test_write_last_stream_frame (line 470) | fn test_write_last_stream_frame() {
  function test_write_eos_frame (line 489) | fn test_write_eos_frame() {
  function test_write_unfinished_stream_frame (line 509) | fn test_write_unfinished_stream_frame() {

FILE: qbase/src/frame/stream_data_blocked.rs
  type StreamDataBlockedFrame (line 20) | pub struct StreamDataBlockedFrame {
    method frame_type (line 26) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 32) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 36) | fn encoding_size(&self) -> usize {
    method new (line 43) | pub fn new(stream_id: StreamId, maximum_stream_data: VarInt) -> Self {
    method stream_id (line 51) | pub fn stream_id(&self) -> StreamId {
    method maximum_stream_data (line 56) | pub fn maximum_stream_data(&self) -> u64 {
  function be_stream_data_blocked_frame (line 63) | pub fn be_stream_data_blocked_frame(input: &[u8]) -> nom::IResult<&[u8],...
  method put_frame (line 76) | fn put_frame(&mut self, frame: &StreamDataBlockedFrame) {
  function test_stream_data_blocked_frame (line 95) | fn test_stream_data_blocked_frame() {
  function test_read_stream_data_blocked (line 106) | fn test_read_stream_data_blocked() {
  function test_write_stream_data_blocked_frame (line 117) | fn test_write_stream_data_blocked_frame() {

FILE: qbase/src/frame/streams_blocked.rs
  type StreamsBlockedFrame (line 19) | pub enum StreamsBlockedFrame {
    method with (line 25) | pub fn with(dir: Dir, max_streams: VarInt) -> Self {
    method frame_type (line 34) | fn frame_type(&self) -> super::FrameType {
    method max_encoding_size (line 43) | fn max_encoding_size(&self) -> usize {
    method encoding_size (line 47) | fn encoding_size(&self) -> usize {
  function streams_blocked_frame_with_dir (line 57) | pub fn streams_blocked_frame_with_dir(
  method put_frame (line 73) | fn put_frame(&mut self, frame: &StreamsBlockedFrame) {
  function test_stream_data_blocked_frame (line 100) | fn test_stream_data_blocked_frame() {
  function test_read_streams_blocked_frame (line 113) | fn test_read_streams_blocked_frame() {
  function test_write_streams_blocked_frame (line 149) | fn test_write_streams_blocked_frame() {

FILE: qbase/src/handshake.rs
  type ClientHandshake (line 23) | pub struct ClientHandshake {
    method is_handshake_done (line 29) | pub fn is_handshake_done(&self) -> bool {
    method recv_handshake_done_frame (line 39) | pub fn recv_handshake_done_frame(&self, _frame: HandshakeDoneFrame) ->...
  type ServerHandshake (line 59) | pub struct ServerHandshake<T>
  function new (line 75) | pub fn new(output: T) -> Self {
  function is_handshake_done (line 83) | pub fn is_handshake_done(&self) -> bool {
  function done (line 100) | pub fn done(&self) -> bool {
  type Handshake (line 119) | pub enum Handshake<T>
  function new (line 134) | pub fn new(role: Role, output: T) -> Self {
  function new_client (line 142) | pub fn new_client() -> Self {
  function new_server (line 149) | pub fn new_server(output: T) -> Self {
  function is_handshake_done (line 154) | pub fn is_handshake_done(&self) -> bool {
  function done (line 166) | pub fn done(&self) -> bool {
  function role (line 174) | pub fn role(&self) -> Role {
  type Output (line 186) | type Output = bool;
  function recv_frame (line 197) | fn recv_frame(&self, frame: HandshakeDoneFrame) -> Result<bool, Error> {
  type HandshakeDoneFrameTx (line 221) | struct HandshakeDoneFrameTx(ArcAsyncDeque<HandshakeDoneFrame>);
    method send_frame (line 224) | fn send_frame<I: IntoIterator<Item = HandshakeDoneFrame>>(&self, iter:...
  function test_client_handshake (line 230) | fn test_client_handshake() {
  function test_client_handshake_done (line 240) | fn test_client_handshake_done() {
  function test_server_handshake (line 253) | fn test_server_handshake() {
  function test_server_recv_handshake_done_frame (line 266) | fn test_server_recv_handshake_done_frame() {
  function test_server_send_handshake_done_frame (line 282) | fn test_server_send_handshake_done_frame() {

FILE: qbase/src/lib.rs
  type Epoch (line 58) | pub enum Epoch {
    constant EPOCHS (line 69) | pub const EPOCHS: [Epoch; 3] = [Epoch::Initial, Epoch::Handshake, Epoc...
    method iter (line 73) | pub fn iter() -> std::slice::Iter<'static, Epoch> {
    method count (line 78) | pub const fn count() -> usize {
  type GetEpoch (line 64) | pub trait GetEpoch {
    method epoch (line 65) | fn epoch(&self) -> Epoch;
  type Output (line 87) | type Output = T;
  function index (line 89) | fn index(&self, index: Epoch) -> &Self::Output {
  function index_mut (line 98) | fn index_mut(&mut self, index: Epoch) -> &mut Self::Output {
  type Receiving (line 104) | pub enum Receiving<F> {
  function recv_frame (line 114) | fn recv_frame(&mut self, frame: F) {
  function reset (line 127) | fn reset(&mut self) {
  type ResetError (line 136) | pub struct ResetError;
  type ArcReceiving (line 139) | pub struct ArcReceiving<F>(Arc<Mutex<Receiving<F>>>);
  function reset (line 142) | pub fn reset(&self) {
  type Output (line 148) | type Output = Result<Option<F>, ResetError>;
  method poll (line 150) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: qbase/src/metric.rs
  type ConnectionMetrics (line 13) | pub struct ConnectionMetrics {
    method new_pending (line 26) | pub fn new_pending(&self, bytes: u64) {
    method on_data_sent (line 34) | pub fn on_data_sent(&self, bytes: u64) {
    method on_data_acked (line 43) | pub fn on_data_acked(&self, bytes: u64) {
    method pending_bytes (line 49) | pub fn pending_bytes(&self) -> u64 {
    method inflight_bytes (line 54) | pub fn inflight_bytes(&self) -> u64 {
    method acked_bytes (line 59) | pub fn acked_bytes(&self) -> u64 {
  type ArcConnectionMetrics (line 65) | pub type ArcConnectionMetrics = Arc<ConnectionMetrics>;
  function test_connection_metrics_new (line 72) | fn test_connection_metrics_new() {
  function test_add_pending_send (line 80) | fn test_add_pending_send() {
  function test_on_data_sent (line 89) | fn test_on_data_sent() {
  function test_on_data_acked (line 98) | fn test_on_data_acked() {
  function test_full_data_flow (line 109) | fn test_full_data_flow() {
  function test_arc_connection_metrics (line 144) | fn test_arc_connection_metrics() {

FILE: qbase/src/net.rs
  type Family (line 29) | pub enum Family {
  method fmt (line 37) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type UnknownFamily (line 52) | pub struct UnknownFamily;
  type Err (line 55) | type Err = UnknownFamily;
  method from_str (line 57) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type AddrFamily (line 66) | pub trait AddrFamily {
    method family (line 70) | fn family(&self) -> Family;
    method family (line 74) | fn family(&self) -> Family {
    method family (line 80) | fn family(&self) -> Family {
    method family (line 86) | fn family(&self) -> Family {
    method family (line 95) | fn family(&self) -> Family {
  type WriteSocketAddr (line 100) | pub trait WriteSocketAddr {
    method put_socket_addr (line 101) | fn put_socket_addr(&mut self, addr: &SocketAddr);
    method put_socket_addr (line 105) | fn put_socket_addr(&mut self, addr: &SocketAddr) {
  function be_socket_addr (line 114) | pub fn be_socket_addr(input: &[u8], family: Family) -> IResult<&[u8], So...
  function be_ip_addr (line 121) | pub fn be_ip_addr(family: Family) -> impl Fn(&[u8]) -> IResult<&[u8], Ip...
  method max_encoding_size (line 129) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 133) | fn encoding_size(&self) -> usize {
  function test_ip_family_display_and_parse (line 146) | fn test_ip_family_display_and_parse() {

FILE: qbase/src/net/addr.rs
  type EndpointAddr (line 14) | pub enum EndpointAddr {
    method direct (line 25) | pub fn direct(addr: SocketAddr) -> Self {
    method with_agent (line 29) | pub fn with_agent(agent: SocketAddr, outer: SocketAddr) -> Self {
    method addr (line 38) | pub fn addr(&self) -> SocketAddr {
    method encoding_size (line 45) | pub fn encoding_size(&self) -> usize {
    method from (line 139) | fn from(addr: SocketAddr) -> Self {
    method from (line 145) | fn from((agent, outer): (SocketAddr, SocketAddr)) -> Self {
  type WriteEndpointAddr (line 66) | pub trait WriteEndpointAddr {
    method put_endpoint_addr (line 67) | fn put_endpoint_addr(&mut self, endpoint: EndpointAddr);
    method put_endpoint_addr (line 71) | fn put_endpoint_addr(&mut self, endpoint: EndpointAddr) {
  function be_endpoint_addr (line 86) | pub fn be_endpoint_addr(
  method fmt (line 102) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Target (line 111) | type Target = SocketAddr;
  method deref (line 113) | fn deref(&self) -> &Self::Target {
  type Err (line 122) | type Err = AddrParseError;
  method from_str (line 124) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: qbase/src/net/nat.rs
  type NatType (line 18) | pub enum NatType {
    type Error (line 34) | type Error = io::Error;
    method try_from (line 36) | fn try_from(value: u8) -> Result<Self, Self::Error> {
    type Error (line 53) | type Error = io::Error;
    method try_from (line 55) | fn try_from(value: VarInt) -> Result<Self, Self::Error> {
    method from (line 61) | fn from(value: NetFeature) -> Self {
  method from (line 28) | fn from(nat_type: NatType) -> Self {

FILE: qbase/src/net/route.rs
  type Pathway (line 14) | pub struct Pathway<E = EndpointAddr> {
  function new (line 21) | pub fn new(local: E, remote: E) -> Self {
  function local (line 26) | pub fn local(&self) -> E
  function remote (line 34) | pub fn remote(&self) -> E
  function map (line 42) | pub fn map<E1>(self, mut f: impl FnMut(E) -> E1) -> Pathway<E1> {
  function flip (line 50) | pub fn flip(self) -> Self {
  method fmt (line 59) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Link (line 65) | pub struct Link {
    method new (line 118) | pub fn new(src: SocketAddr, dst: SocketAddr) -> Self {
    method flip (line 123) | pub fn flip(self) -> Self {
  method fmt (line 71) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function be_link (line 76) | pub fn be_link(input: &[u8]) -> nom::IResult<&[u8], Link> {
  type WriteLink (line 93) | pub trait WriteLink {
    method put_link (line 94) | fn put_link(&mut self, link: &Link);
    method put_link (line 98) | fn put_link(&mut self, link: &Link) {
  method max_encoding_size (line 107) | fn max_encoding_size(&self) -> usize {
  method encoding_size (line 111) | fn encoding_size(&self) -> usize {
  function from (line 132) | fn from(link: Link) -> Self {
  type Line (line 138) | pub struct Line {
    constant DEFAULT_TTL (line 150) | pub const DEFAULT_TTL: u8 = 64;
    method new (line 152) | pub fn new(link: Link, ttl: u8, ecn: Option<u8>, seg_size: u16) -> Self {
  method default (line 163) | fn default() -> Self {
  type Route (line 177) | pub struct Route {
    method new (line 185) | pub fn new(pathway: Pathway, line: Line) -> Self {
    method empty (line 190) | pub fn empty() -> Self {
    method pathway (line 197) | pub fn pathway(&self) -> Pathway {
    method link (line 201) | pub fn link(&self) -> Link {
    method ttl (line 205) | pub fn ttl(&self) -> u8 {
    method ecn (line 209) | pub fn ecn(&self) -> Option<u8> {
    method seg_size (line 213) | pub fn seg_size(&self) -> u16 {
  function test_endpoint_addr_from_str (line 223) | fn test_endpoint_addr_from_str() {

FILE: qbase/src/net/tx.rs
  type SignalsBits (line 10) | type SignalsBits = u16;
  type SendWaker (line 29) | pub struct SendWaker {
    method new (line 36) | pub fn new() -> Self {
    constant WAITING (line 40) | const WAITING: SignalsBits = 0;
    method poll_wait_for (line 43) | pub fn poll_wait_for(&mut self, cx: &mut Context, signals: Signals) ->...
    method wake_by (line 58) | fn wake_by(&mut self, signals: Signals) {
  type ArcSendWaker (line 72) | pub struct ArcSendWaker(Arc<Mutex<SendWaker>>);
    method new (line 76) | pub fn new() -> Self {
    method wait_for (line 81) | pub async fn wait_for(&self, signals: Signals) {
    method wake_by (line 86) | pub fn wake_by(&self, signals: Signals) {
    method state (line 178) | fn state(&self) -> SignalsBits {
  type SendWakers (line 93) | pub struct SendWakers {
    method new (line 100) | pub fn new() -> Self {
    method insert (line 105) | pub fn insert(&mut self, pathway: Pathway, waker: &ArcSendWaker) {
    method remove (line 110) | pub fn remove(&mut self, pathway: &Pathway) {
    method wake_all_by (line 115) | pub fn wake_all_by(&mut self, signals: Signals) {
  type ArcSendWakers (line 145) | pub struct ArcSendWakers(Arc<Mutex<SendWakers>>);
    method new (line 149) | pub fn new() -> Self {
    method lock_guard (line 153) | fn lock_guard(&self) -> MutexGuard<'_, SendWakers> {
    method insert (line 158) | pub fn insert(&self, pathway: Pathway, waker: &ArcSendWaker) {
    method remove (line 163) | pub fn remove(&self, pathway: &Pathway) {
    method wake_all_by (line 168) | pub fn wake_all_by(&self, signals: Signals) {
  function single_condition (line 186) | async fn single_condition() {
  function all_condition (line 215) | async fn all_condition() {
  function wake_before_register (line 249) | async fn wake_before_register() {
  function state_change (line 274) | async fn state_change() {
  function mult_wake_signals (line 333) | async fn mult_wake_signals() {
  function not_wake (line 364) | async fn not_wake() {

FILE: qbase/src/packet.rs
  type DataHeader (line 66) | pub enum DataHeader {
  type DataPacket (line 86) | pub struct DataPacket {
  method get_type (line 96) | fn get_type(&self) -> Type {
  type PacketContent (line 102) | pub enum PacketContent {
    method is_ack_eliciting (line 110) | pub fn is_ack_eliciting(self) -> bool {
    method from (line 116) | fn from(frame_type: FrameType) -> Self {
    method add_assign (line 126) | fn add_assign(&mut self, rhs: FrameType) {
    method add_assign (line 136) | fn add_assign(&mut self, rhs: Self) {
  type Packet (line 149) | pub enum Packet {
  type PacketReader (line 165) | pub struct PacketReader {
    method new (line 172) | pub fn new(raw_bytes: BytesMut, dcid_len: usize) -> Self {
  type Item (line 181) | type Item = Result<Packet, error::Error>;
  method next (line 183) | fn next(&mut self) -> Option<Self::Item> {

FILE: qbase/src/packet/decrypt.rs
  function remove_protection_of_long_packet (line 27) | pub fn remove_protection_of_long_packet(
  function remove_protection_of_short_packet (line 69) | pub fn remove_protection_of_short_packet(
  function decrypt_packet (line 107) | pub fn decrypt_packet(

FILE: qbase/src/packet/encrypt.rs
  function encrypt_packet (line 20) | pub fn encrypt_packet(key: &dyn PacketKey, pn: u64, pkt_buf: &mut [u8], ...
  function protect_header (line 44) | pub fn protect_header(
  function encode_long_first_byte (line 61) | pub fn encode_long_first_byte(first_byte: &mut u8, pn_len: usize) {
  function encode_short_first_byte (line 68) | pub fn encode_short_first_byte(first_byte: &mut u8, pn_len: usize, key_p...

FILE: qbase/src/packet/error.rs
  type Error (line 8) | pub enum Error {
    method from_error_kind (line 30) | fn from_error_kind(_input: &[u8], _kind: NomErrorKind) -> Self {
    method append (line 35) | fn append(_input: &[u8], _kind: NomErrorKind, source: Self) -> Self {
  function from (line 44) | fn from(e: Error) -> Self {

FILE: qbase/src/packet/header.rs
  type GetType (line 27) | pub trait GetType {
    method get_type (line 29) | fn get_type(&self) -> Type;
  type EncodeHeader (line 38) | pub trait EncodeHeader {
    method size (line 40) | fn size(&self) -> usize {
    method length_encoding (line 44) | fn length_encoding(&self) -> usize {
  type GetDcid (line 51) | pub trait GetDcid {
    method dcid (line 53) | fn dcid(&self) -> &ConnectionId;
  type GetScid (line 58) | pub trait GetScid {
    method scid (line 60) | fn scid(&self) -> &ConnectionId;
  type Header (line 66) | pub enum Header {
  function be_header (line 94) | pub fn be_header(
  type WriteHeader (line 118) | pub trait WriteHeader<H>: bytes::BufMut {
    method put_header (line 120) | fn put_header(&mut self, header: &H);
  method put_header (line 133) | fn put_header(&mut self, header: &Header) {
  function test_read_header (line 169) | fn test_read_header() {
  function test_write_header (line 275) | fn test_write_header() {

FILE: qbase/src/packet/header/long.rs
  type LongHeader (line 27) | pub struct LongHeader<T> {
  function dcid (line 36) | fn dcid(&self) -> &ConnectionId {
  function scid (line 42) | fn scid(&self) -> &ConnectionId {
  type VersionNegotiation (line 57) | pub struct VersionNegotiation {
    method new (line 63) | pub fn new(versions: Vec<u32>) -> Self {
    method versions (line 68) | pub fn versions(&self) -> &Vec<u32> {
  type Retry (line 80) | pub struct Retry {
    method new (line 90) | pub fn new(token: &[u8], integrity: &[u8]) -> Self {
    method token (line 100) | pub fn token(&self) -> &Vec<u8> {
    method integrity (line 105) | pub fn integrity(&self) -> &[u8; 16] {
  type Initial (line 117) | pub struct Initial {
    method with_token (line 123) | pub fn with_token(token: Vec<u8>) -> Self {
    method from_slice (line 128) | pub fn from_slice(token: &[u8]) -> Self {
    method token (line 135) | pub fn token(&self) -> &Vec<u8> {
  type ZeroRtt (line 142) | pub struct ZeroRtt;
  type Handshake (line 146) | pub struct Handshake;
  method size (line 149) | fn size(&self) -> usize {
  type VersionNegotiationHeader (line 164) | pub type VersionNegotiationHeader = LongHeader<VersionNegotiation>;
  type RetryHeader (line 170) | pub type RetryHeader = LongHeader<Retry>;
  type InitialHeader (line 176) | pub type InitialHeader = LongHeader<Initial>;
  type HandshakeHeader (line 182) | pub type HandshakeHeader = LongHeader<Handshake>;
  type ZeroRttHeader (line 188) | pub type ZeroRttHeader = LongHeader<ZeroRtt>;
  method size (line 191) | fn size(&self) -> usize {
  method length_encoding (line 198) | fn length_encoding(&self) -> usize {
  type DataHeader (line 227) | pub enum DataHeader {
  function be_version_negotiation (line 261) | pub fn be_version_negotiation(input: &[u8]) -> nom::IResult<&[u8], Versi...
  function be_retry (line 268) | pub fn be_retry(input: &[u8]) -> nom::IResult<&[u8], Retry> {
  function be_initial (line 279) | pub fn be_initial(input: &[u8]) -> nom::IResult<&[u8], Initial> {
  function be_zero_rtt (line 285) | pub fn be_zero_rtt(input: &[u8]) -> nom::IResult<&[u8], ZeroRtt> {
  function be_handshake (line 291) | pub fn be_handshake(input: &[u8]) -> nom::IResult<&[u8], Handshake> {
  type LongHeaderBuilder (line 306) | pub struct LongHeaderBuilder {
    method with_cid (line 314) | pub fn with_cid(dcid: ConnectionId, scid: ConnectionId) -> Self {
    method vn (line 319) | pub fn vn(self, versions: Vec<u32>) -> LongHeader<VersionNegotiation> {
    method retry (line 324) | pub fn retry(self, token: Vec<u8>, integrity: [u8; 16]) -> LongHeader<...
    method initial (line 329) | pub fn initial(self, token: Vec<u8>) -> LongHeader<Initial> {
    method zero_rtt (line 334) | pub fn zero_rtt(self) -> LongHeader<ZeroRtt> {
    method handshake (line 339) | pub fn handshake(self) -> LongHeader<Handshake> {
    method wrap (line 345) | pub fn wrap<T>(self, specific: T) -> LongHeader<T> {
    method parse (line 357) | pub fn parse(self, ty: LongType, input: &[u8]) -> nom::IResult<&[u8], ...
  type WriteSpecific (line 386) | pub trait WriteSpecific<S>: BufMut {
    method put_specific (line 388) | fn put_specific(&mut self, _specific: &S) {}
  method put_specific (line 392) | fn put_specific(&mut self, specific: &VersionNegotiation) {
  method put_specific (line 400) | fn put_specific(&mut self, specific: &Retry) {
  method put_specific (line 407) | fn put_specific(&mut self, specific: &Initial) {
  method put_header (line 426) | fn put_header(&mut self, header: &LongHeader<S>) {
  function test_be_version_negotiation (line 441) | fn test_be_version_negotiation() {
  function test_be_retry (line 451) | fn test_be_retry() {
  function test_be_initial (line 479) | fn test_be_initial() {
  function test_write_version_negotiation_long_header (line 490) | fn test_write_version_negotiation_long_header() {
  function test_write_retry_long_header (line 503) | fn test_write_retry_long_header() {
  function test_write_initial_long_header (line 529) | fn test_write_initial_long_header() {

FILE: qbase/src/packet/header/short.rs
  type OneRttHeader (line 23) | pub struct OneRttHeader {
    method new (line 31) | pub fn new(spin: SpinBit, dcid: ConnectionId) -> Self {
    method spin (line 36) | pub fn spin(&self) -> SpinBit {
    method dcid (line 54) | fn dcid(&self) -> &ConnectionId {
  method size (line 42) | fn size(&self) -> usize {
  method get_type (line 48) | fn get_type(&self) -> Type {
  function be_one_rtt_header (line 68) | pub fn be_one_rtt_header(
  method put_header (line 80) | fn put_header(&mut self, header: &OneRttHeader) {
  function test_read_one_rtt_header (line 93) | fn test_read_one_rtt_header() {
  function test_write_one_rtt_header (line 105) | fn test_write_one_rtt_header() {

FILE: qbase/src/packet/io.rs
  function be_payload (line 24) | fn be_payload(
  function be_packet (line 47) | pub fn be_packet(datagram: &mut BytesMut, dcid_len: usize) -> Result<Pac...
  type ProductHeader (line 109) | pub trait ProductHeader<H> {
    method new_header (line 110) | fn new_header(&self) -> Result<H, Signals>;
  type PacketSpace (line 113) | pub trait PacketSpace<H> {
    method new_packet (line 118) | fn new_packet<'b>(
  type Package (line 126) | pub trait Package<Target: ?Sized> {
    method dump (line 127) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signa...
  function dump (line 132) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  function dump (line 139) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  function dump (line 146) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  function dump (line 154) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  function dump (line 173) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  type PadTo20 (line 190) | pub struct PadTo20;
    method dump (line 197) | fn dump(&mut self, target: &mut P) -> Result<PacketContent, Signals> {
  type PadToFull (line 210) | pub struct PadToFull;
    method dump (line 217) | fn dump(&mut self, target: &mut P) -> Result<PacketContent, Signals> {
  type PadProbe (line 230) | pub struct PadProbe;
    method dump (line 237) | fn dump(&mut self, target: &mut P) -> Result<PacketContent, Signals> {
  type Repeat (line 246) | pub struct Repeat<P>(pub P);
  function dump (line 250) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  type Packages (line 266) | pub struct Packages<T>(pub T);
  type Keys (line 379) | pub enum Keys {
    method hpk (line 406) | fn hpk(&self) -> &dyn rustls::quic::HeaderProtectionKey {
    method pk (line 414) | fn pk(&self) -> &dyn rustls::quic::PacketKey {
    method key_phase (line 422) | fn key_phase(&self) -> Option<KeyPhaseBit> {
  method fmt (line 390) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type PacketLayout (line 431) | struct PacketLayout {
    method payload_len (line 441) | pub fn payload_len(&self) -> usize {
    method is_empty (line 445) | pub fn is_empty(&self) -> bool {
  type PacketInfo (line 451) | pub struct PacketInfo {
    method new (line 478) | pub fn new(ty: Type, pn: u64) -> Self {
    method epoch (line 489) | pub fn epoch(&self) -> Option<Epoch> {
    method add_frame (line 504) | pub fn add_frame<F: FrameFeature + 'static>(&mut self, frame: &F) {
    method record_frame (line 528) | fn record_frame(&mut self, frame: &Frame<D>) {
  type RecordFrame (line 523) | pub trait RecordFrame<F, D: ContinuousData> {
    method record_frame (line 524) | fn record_frame(&mut self, frame: &F);
  function record_frame (line 552) | fn record_frame(&mut self, frame: &F) {
  type PacketWriter (line 557) | pub struct PacketWriter<'b> {
  function new_long (line 565) | pub fn new_long<S>(
  function new_short (line 601) | pub fn new_short(
  function buffer (line 631) | pub fn buffer(&self) -> &[u8] {
  function is_short_header (line 636) | pub fn is_short_header(&self) -> bool {
  function packet_type (line 641) | pub fn packet_type(&self) -> Type {
  function packet_number (line 646) | pub fn packet_number(&self) -> u64 {
  function is_ack_eliciting (line 651) | pub fn is_ack_eliciting(&self) -> bool {
  function in_flight (line 656) | pub fn in_flight(&self) -> bool {
  function is_probe_new_path (line 661) | pub fn is_probe_new_path(&self) -> bool {
  function payload_len (line 666) | pub fn payload_len(&self) -> usize {
  function tag_len (line 671) | pub fn tag_len(&self) -> usize {
  function is_empty (line 676) | pub fn is_empty(&self) -> bool {
  function packet_len (line 681) | pub fn packet_len(&self) -> usize {
  method remaining_mut (line 688) | fn remaining_mut(&self) -> usize {
  method advance_mut (line 693) | unsafe fn advance_mut(&mut self, cnt: usize) {
  method chunk_mut (line 706) | fn chunk_mut(&mut self) -> &mut UninitSlice {
  type AssemblePacket (line 712) | pub trait AssemblePacket: BufMut {
    method assemble_packet (line 714) | fn assemble_packet(
    method encrypt_and_protect_packet (line 721) | fn encrypt_and_protect_packet(self) -> (usize, PacketInfo);
    method encrypt_and_protect_packet (line 725) | fn encrypt_and_protect_packet(self) -> (usize, PacketInfo) {
  type TransparentKeys (line 787) | struct TransparentKeys;
    method decrypt_in_place (line 790) | fn decrypt_in_place<'a>(
    method encrypt_in_place (line 799) | fn encrypt_in_place(
    method confidentiality_limit (line 808) | fn confidentiality_limit(&self) -> u64 {
    method integrity_limit (line 812) | fn integrity_limit(&self) -> u64 {
    method tag_len (line 816) | fn tag_len(&self) -> usize {
    method decrypt_in_place (line 822) | fn decrypt_in_place(
    method encrypt_in_place (line 831) | fn encrypt_in_place(
    method sample_len (line 840) | fn sample_len(&self) -> usize {
  function test_initial_packet_writer (line 846) | fn test_initial_packet_writer() {

FILE: qbase/src/packet/keys.rs
  type DirectionalKeys (line 17) | pub struct DirectionalKeys {
    method from (line 25) | fn from(keys: RustlsDirectionalKeys) -> Self {
  type Keys (line 35) | pub struct Keys {
    method from (line 43) | fn from(keys: RustlsKeys) -> Self {
  type KeysState (line 55) | enum KeysState<K> {
  function set (line 62) | fn set(&mut self, keys: K) {
  function get (line 75) | fn get(&mut self) -> Option<&K> {
  function invalid (line 82) | fn invalid(&mut self) -> Option<K> {
  type Output (line 97) | type Output = Option<K>;
  method poll (line 99) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type ArcKeys (line 132) | pub struct ArcKeys(Arc<Mutex<KeysState<Keys>>>);
    method lock_guard (line 135) | fn lock_guard(&self) -> MutexGuard<'_, KeysState<Keys>> {
    method new_pending (line 145) | pub fn new_pending() -> Self {
    method with_keys (line 152) | pub fn with_keys(keys: Keys) -> Self {
    method get_remote_keys (line 180) | pub fn get_remote_keys(&self) -> GetRemoteKeys<'_, Keys> {
    method get_local_keys (line 207) | pub fn get_local_keys(&self) -> Option<Keys> {
    method set_keys (line 217) | pub fn set_keys(&self, keys: Keys) {
    method invalid (line 227) | pub fn invalid(&self) -> Option<Keys> {
  type GetRemoteKeys (line 234) | pub struct GetRemoteKeys<'k, K>(&'k Mutex<KeysState<K>>);
  type Output (line 237) | type Output = Option<K>;
  method poll (line 239) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type ArcZeroRttKeys (line 245) | pub struct ArcZeroRttKeys {
    method new_pending (line 251) | pub fn new_pending(role: Role) -> Self {
    method lock_guard (line 258) | fn lock_guard(&self) -> MutexGuard<'_, KeysState<DirectionalKeys>> {
    method set_keys (line 262) | pub fn set_keys(&self, keys: DirectionalKeys) {
    method get_encrypt_keys (line 266) | pub fn get_encrypt_keys(&self) -> Option<DirectionalKeys> {
    method get_decrypt_keys (line 273) | pub fn get_decrypt_keys(&self) -> Option<GetRemoteKeys<'_, Directional...
    method invalid (line 280) | pub fn invalid(&self) -> Option<DirectionalKeys> {
  type OneRttPacketKeys (line 290) | pub struct OneRttPacketKeys {
    method new (line 302) | fn new(remote: Box<dyn PacketKey>, local: Box<dyn PacketKey>, secrets:...
    method update (line 316) | pub fn update(&mut self) {
    method phase_out (line 328) | pub fn phase_out(&mut self) {
    method get_remote (line 336) | pub fn get_remote(&mut self, key_phase: KeyPhaseBit, _pn: u64) -> Arc<...
    method get_local (line 346) | pub fn get_local(&self) -> (KeyPhaseBit, Arc<dyn PacketKey>) {
  type ArcOneRttPacketKeys (line 358) | pub struct ArcOneRttPacketKeys(Arc<(Mutex<OneRttPacketKeys>, usize)>);
    method lock_guard (line 364) | pub fn lock_guard(&self) -> MutexGuard<'_, OneRttPacketKeys> {
    method tag_len (line 379) | pub fn tag_len(&self) -> usize {
  type HeaderProtectionKeys (line 386) | pub struct HeaderProtectionKeys {
  type OneRttKeysState (line 391) | enum OneRttKeysState {
  type ArcOneRttKeys (line 409) | pub struct ArcOneRttKeys(Arc<Mutex<OneRttKeysState>>);
    method lock_guard (line 412) | fn lock_guard(&self) -> MutexGuard<'_, OneRttKeysState> {
    method new_pending (line 418) | pub fn new_pending() -> Self {
    method set_keys (line 427) | pub fn set_keys(&self, keys: RustlsKeys, secrets: Secrets) {
    method invalid (line 454) | pub fn invalid(&self) -> Option<(HeaderProtectionKeys, ArcOneRttPacket...
    method get_local_keys (line 473) | pub fn get_local_keys(&self) -> Option<(Arc<dyn HeaderProtectionKey>, ...
    method remote_keys (line 481) | pub fn remote_keys(&self) -> Option<(Arc<dyn HeaderProtectionKey>, Arc...
    method get_remote_keys (line 491) | pub fn get_remote_keys(&self) -> GetRemoteOneRttKeys<'_> {
  type GetRemoteOneRttKeys (line 498) | pub struct GetRemoteOneRttKeys<'k>(&'k ArcOneRttKeys);
  type Output (line 501) | type Output = Option<(Arc<dyn HeaderProtectionKey>, ArcOneRttPacketKeys)>;
  method poll (line 503) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: qbase/src/packet/number.rs
  type PacketNumber (line 14) | pub enum PacketNumber {
    method encode (line 90) | pub fn encode(pn: u64, largest_acked: u64) -> Self {
    method size (line 107) | pub fn size(self) -> usize {
    method decode (line 125) | pub fn decode(self, expected: u64) -> u64 {
  type InvalidPacketNumber (line 22) | pub enum InvalidPacketNumber {
  type WritePacketNumber (line 32) | pub trait WritePacketNumber {
    method put_packet_number (line 34) | fn put_packet_number(&mut self, pn: PacketNumber);
    method put_packet_number (line 38) | fn put_packet_number(&mut self, pn: PacketNumber) {
  function take_pn_len (line 66) | pub fn take_pn_len(pn_len: u8) -> impl FnMut(&[u8]) -> nom::IResult<&[u8...
  function test_read_packet_number (line 161) | fn test_read_packet_number() {
  function test_read_packet_number_too_large (line 189) | fn test_read_packet_number_too_large() {
  function test_write_packet_number (line 195) | fn test_write_packet_number() {
  function test_encode_packet_number (line 215) | fn test_encode_packet_number() {
  function test_encode_packet_number_overflow (line 225) | fn test_encode_packet_number_overflow() {

FILE: qbase/src/packet/signal.rs
  constant SPIN_BIT (line 2) | const SPIN_BIT: u8 = 0x20;
  constant KEY_PHASE_BIT (line 4) | const KEY_PHASE_BIT: u8 = 0x04;
  type Toggle (line 8) | pub enum Toggle<const B: u8> {
  type SpinBit (line 17) | pub type SpinBit = Toggle<SPIN_BIT>;
  type KeyPhaseBit (line 20) | pub type KeyPhaseBit = Toggle<KEY_PHASE_BIT>;
  function toggle (line 24) | pub fn toggle(&mut self) {
  function value (line 32) | pub fn value(&self) -> u8 {
  function imply (line 40) | pub fn imply(&self, byte: &mut u8) {
  function as_index (line 48) | pub(crate) fn as_index(&self) -> usize {
  type Output (line 57) | type Output = Self;
  function not (line 59) | fn not(self) -> Self::Output {
  function from (line 68) | fn from(value: u8) -> Self {
  function from (line 78) | fn from(value: Toggle<B>) -> Self {
  function from (line 84) | fn from(value: bool) -> Self {
  function from (line 90) | fn from(value: Toggle<B>) -> Self {

FILE: qbase/src/packet/type.rs
  constant HEADER_FORM_MASK (line 11) | const HEADER_FORM_MASK: u8 = 0x80;
  constant FIXED_BIT (line 13) | const FIXED_BIT: u8 = 0x40;
  constant LONG_RESERVED_MASK (line 16) | pub const LONG_RESERVED_MASK: u8 = 0x0C;
  constant SHORT_RESERVED_MASK (line 18) | pub const SHORT_RESERVED_MASK: u8 = 0x18;
  type SpecificBits (line 26) | pub struct SpecificBits<const R: u8>(pub(super) u8);
  type LongSpecificBits (line 32) | pub type LongSpecificBits = SpecificBits<LONG_RESERVED_MASK>;
  type ShortSpecificBits (line 38) | pub type ShortSpecificBits = SpecificBits<SHORT_RESERVED_MASK>;
    method set_key_phase (line 55) | pub fn set_key_phase(&mut self, key_phase_bit: KeyPhaseBit) {
    method key_phase (line 60) | pub fn key_phase(&self) -> KeyPhaseBit {
  function from_pn (line 42) | pub fn from_pn(pn: &PacketNumber) -> Self {
  function with_pn_len (line 47) | pub fn with_pn_len(pn_size: usize) -> Self {
  function from (line 66) | fn from(byte: u8) -> Self {
  type GetPacketNumberLength (line 77) | pub trait GetPacketNumberLength {
    constant PN_LEN_MASK (line 79) | const PN_LEN_MASK: u8 = 0x03;
    method pn_len (line 82) | fn pn_len(&self) -> Result<u8, Error>;
    method pn_len (line 86) | fn pn_len(&self) -> Result<u8, Error> {
  type Type (line 107) | pub enum Type {
    method encoding_size (line 114) | pub fn encoding_size(&self) -> usize {
  function be_packet_type (line 130) | pub fn be_packet_type(input: &[u8]) -> nom::IResult<&[u8], Type, Error> {
  type WritePacketType (line 141) | pub trait WritePacketType: BufMut {
    method put_packet_type (line 143) | fn put_packet_type(&mut self, ty: &Type);
    method put_packet_type (line 147) | fn put_packet_type(&mut self, ty: &Type) {
  function test_long_clear_bits (line 161) | fn test_long_clear_bits() {
  function test_short_specific_bits (line 189) | fn test_short_specific_bits() {
  function test_set_key_phase_bit (line 217) | fn test_set_key_phase_bit() {

FILE: qbase/src/packet/type/long.rs
  type Version (line 12) | pub struct Version<const N: u32, Ty>(#[deref] pub(crate) Ty);
  type GetVersion (line 16) | pub trait GetVersion {
    method get_version (line 18) | fn get_version(&self) -> u32;
    method get_version (line 22) | fn get_version(&self) -> u32 {
  constant RETRY (line 30) | pub const RETRY: Self = Self(v1::Type::Retry);
  constant INITIAL (line 32) | pub const INITIAL: Self = Self(v1::Type::Initial);
  constant ZERO_RTT (line 34) | pub const ZERO_RTT: Self = Self(v1::Type::ZeroRtt);
  constant HANDSHAKE (line 36) | pub const HANDSHAKE: Self = Self(v1::Type::Handshake);
  type Ver1 (line 40) | pub type Ver1 = Version<1, v1::Type>;
  type Type (line 44) | pub enum Type {
  constant LONG_HEADER_BIT (line 59) | const LONG_HEADER_BIT: u8 = 0x80;
  function parse_long_type (line 63) | pub fn parse_long_type(ty: u8) -> impl FnMut(&[u8]) -> nom::IResult<&[u8...
  type WriteLongType (line 80) | pub trait WriteLongType: BufMut {
    method put_long_type (line 82) | fn put_long_type(&mut self, value: &Type);
    method put_long_type (line 86) | fn put_long_type(&mut self, value: &Type) {
  function test_read_long_type (line 107) | fn test_read_long_type() {
  function test_read_long_type_with_wrong_version (line 123) | fn test_read_long_type_with_wrong_version() {
  function test_write_long_type (line 133) | fn test_write_long_type() {
  function test_write_version_negotiation_long_type (line 144) | fn test_write_version_negotiation_long_type() {

FILE: qbase/src/packet/type/long/v1.rs
  type Type (line 9) | pub enum Type {
    type Error (line 38) | type Error = Error;
    method try_from (line 40) | fn try_from(value: u8) -> Result<Self, Self::Error> {
  constant LONG_PACKET_TYPE_MASK (line 20) | const LONG_PACKET_TYPE_MASK: u8 = 0x30;
  constant INITIAL_PACKET_TYPE (line 21) | const INITIAL_PACKET_TYPE: u8 = 0x00;
  constant ZERO_RTT_PACKET_TYPE (line 22) | const ZERO_RTT_PACKET_TYPE: u8 = 0x10;
  constant HANDSHAKE_PACKET_TYPE (line 23) | const HANDSHAKE_PACKET_TYPE: u8 = 0x20;
  constant RETRY_PACKET_TYPE (line 24) | const RETRY_PACKET_TYPE: u8 = 0x30;
  function from (line 27) | fn from(value: Type) -> u8 {
  function test_try_from (line 58) | fn test_try_from() {

FILE: qbase/src/packet/type/short.rs
  constant SHORT_HEADER_BIT (line 6) | const SHORT_HEADER_BIT: u8 = 0x00;
  type OneRtt (line 11) | pub struct OneRtt(#[deref] pub SpinBit);
    method from (line 14) | fn from(value: u8) -> Self {
  function from (line 20) | fn from(one_rtt: OneRtt) -> Self {
  type WriteShortType (line 26) | pub trait WriteShortType: BufMut {
    method put_short_type (line 28) | fn put_short_type(&mut self, ty: &OneRtt);
    method put_short_type (line 32) | fn put_short_type(&mut self, ty: &OneRtt) {
  function test_write_short_type (line 42) | fn test_write_short_type() {

FILE: qbase/src/param.rs
  type Requirements (line 57) | enum Requirements {
  type Parameters (line 90) | pub struct Parameters {
    constant CLIENT_READY (line 106) | const CLIENT_READY: u8 = 1;
    constant SERVER_READY (line 107) | const SERVER_READY: u8 = 2;
    method new_client (line 114) | pub fn new_client(
    method new_server (line 138) | pub fn new_server(server: ServerParameters) -> Self {
    method role (line 149) | pub fn role(&self) -> Role {
    method client (line 156) | pub fn client(&self) -> Option<&Arc<ClientParameters>> {
    method server (line 164) | pub fn server(&self) -> Option<&Arc<ServerParameters>> {
    method remembered (line 178) | pub fn remembered(&self) -> Option<&Arc<ServerParameters>> {
    method get_local (line 182) | pub fn get_local<V: TryFrom<ParameterValue>>(&self, id: ParameterId) -...
    method get_remote (line 189) | pub fn get_remote<V: TryFrom<ParameterValue>>(&self, id: ParameterId) ...
    method poll_ready (line 201) | pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<()> {
    method is_remote_params_received (line 210) | pub fn is_remote_params_received(&self) -> bool {
    method is_remote_params_ready (line 221) | pub fn is_remote_params_ready(&self) -> bool {
    method recv_remote_params (line 229) | pub fn recv_remote_params(
    method wake_all (line 260) | fn wake_all(&mut self) {
    method initial_scid_from_peer_need_equal (line 274) | pub fn initial_scid_from_peer_need_equal(
    method retry_scid_from_server_need_equal (line 301) | pub fn retry_scid_from_server_need_equal(&mut self, cid: ConnectionId) {
    method initial_scid_from_peer (line 308) | pub fn initial_scid_from_peer(&self) -> Option<ConnectionId> {
    method authenticate_cids (line 315) | fn authenticate_cids(&self) -> Result<bool, QuicError> {
    method negotiated_max_idle_timeout (line 381) | pub fn negotiated_max_idle_timeout(&self) -> Option<Duration> {
  method drop (line 100) | fn drop(&mut self) {
  type ArcParameters (line 420) | pub struct ArcParameters(Arc<Mutex<Result<Parameters, Error>>>);
    method from (line 442) | fn from(params: Parameters) -> Self {
    method lock_guard (line 449) | pub fn lock_guard(&self) -> Result<ParametersGuard<'_>, Error> {
    method remote_ready (line 458) | pub async fn remote_ready(&self) -> Result<ParametersGuard<'_>, Error> {
    method on_conn_error (line 480) | pub fn on_conn_error(&self, error: &Error) {
  type ParametersGuard (line 425) | pub struct ParametersGuard<'a>(MutexGuard<'a, Result<Parameters, Error>>);
  type Target (line 428) | type Target = Parameters;
  method deref (line 430) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 436) | fn deref_mut(&mut self) -> &mut Self::Target {
  function create_test_client_params (line 495) | fn create_test_client_params() -> ClientParameters {
  function create_test_server_params (line 506) | fn create_test_server_params() -> ServerParameters {
  function test_parameters_new (line 524) | fn test_parameters_new() {
  function test_authenticate_cids (line 538) | fn test_authenticate_cids() {
  function test_parameters_as_client (line 565) | fn test_parameters_as_client() {
  function test_validate_remote_params (line 587) | fn test_validate_remote_params() {
  function test_write_parameters (line 614) | fn test_write_parameters() {
  function test_arc_parameters_error_handling (line 628) | async fn test_arc_parameters_error_handling() {

FILE: qbase/src/param/core.rs
  type ParameterValueType (line 15) | pub enum ParameterValueType {
  type ParameterValue (line 26) | pub enum ParameterValue {
    method value_type (line 37) | pub fn value_type(&self) -> ParameterValueType {
    method from (line 51) | fn from(value: u32) -> Self {
    method from (line 57) | fn from(value: String) -> Self {
  type Error (line 63) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 66) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 75) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 78) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 87) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 90) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 99) | type Error = <VarInt as TryFrom<ParameterValue>>::Error;
  function try_from (line 102) | fn try_from(value: ParameterValue) -> Result<Self, Self::Error> {
  type Error (line 108) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 111) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 124) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 127) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 136) | type Error = TryIntoError<ParameterValue>;
  function try_from (line 139) | fn try_from(value: ParameterValue) -> Result<Self, Self::Error> {
  type Error (line 148) | type Error = TryIntoError<ParameterValue>;
  method try_from (line 151) | fn try_from(value: ParameterValue) -> Result<Self, TryIntoError<Paramete...
  type Error (line 160) | type Error = <Bytes as TryFrom<ParameterValue>>::Error;
  method try_from (line 163) | fn try_from(value: ParameterValue) -> Result<Self, Self::Error> {
  type ParameterId (line 171) | pub enum ParameterId {
    method belong_to (line 216) | pub fn belong_to(self, role: Role) -> Result<(), Error> {
    method fmt (line 235) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Parameters (line 241) | pub struct Parameters<Role> {
  function get (line 247) | pub fn get<V>(&self, id: ParameterId) -> Option<V>
  function contains (line 255) | pub fn contains(&self, id: ParameterId) -> bool {
  function is_empty (line 259) | pub fn is_empty(&self) -> bool {
  function new (line 265) | pub fn new() -> Self {
  function set (line 269) | pub fn set(&mut self, id: ParameterId, value: impl Into<ParameterValue>)...
  type ClientParameters (line 279) | pub type ClientParameters = Parameters<Client>;
  type ServerParameters (line 280) | pub type ServerParameters = Parameters<Server>;
    method is_0rtt_accepted (line 284) | pub fn is_0rtt_accepted(&self, server_params: &ServerParameters) -> bo...
  type PeerParameters (line 306) | pub enum PeerParameters {

FILE: qbase/src/param/error.rs
  type Error (line 16) | pub enum Error {
    method from_error_kind (line 44) | fn from_error_kind(_input: &[u8], _kind: NomErrorKind) -> Self {
    method append (line 48) | fn append(_input: &[u8], _kind: NomErrorKind, source: Self) -> Self {
  method from (line 34) | fn from(e: Error) -> Self {

FILE: qbase/src/param/handy.rs
  function client_parameters (line 5) | pub fn client_parameters() -> super::ClientParameters {
  function server_parameters (line 27) | pub fn server_parameters() -> super::ServerParameters {

FILE: qbase/src/param/io.rs
  type WriteParameterId (line 21) | pub trait WriteParameterId: bytes::BufMut {
    method put_parameter_id (line 23) | fn put_parameter_id(&mut self, param_id: ParameterId);
    method put_parameter_id (line 27) | fn put_parameter_id(&mut self, param_id: ParameterId) {
  function be_raw_parameter (line 32) | pub fn be_raw_parameter(input: &[u8]) -> nom::IResult<&[u8], (VarInt, &[...
  function be_parameter_value (line 38) | pub fn be_parameter_value(input: &[u8], id: ParameterId) -> nom::IResult...
  type WriteParameter (line 64) | pub trait WriteParameter {
    method put_bytes_parameter (line 65) | fn put_bytes_parameter(&mut self, id: ParameterId, bytes: &Bytes);
    method put_cid_parameter (line 67) | fn put_cid_parameter(&mut self, id: ParameterId, cid: &ConnectionId);
    method put_duration_parameter (line 69) | fn put_duration_parameter(&mut self, id: ParameterId, dur: &Duration) {
    method put_bool_parameter (line 74) | fn put_bool_parameter(&mut self, id: ParameterId);
    method put_preferred_address_parameter (line 76) | fn put_preferred_address_parameter(&mut self, id: ParameterId, addr: &...
    method put_reset_token_parameter (line 78) | fn put_reset_token_parameter(&mut self, id: ParameterId, token: &Reset...
    method put_varint_parameter (line 80) | fn put_varint_parameter(&mut self, id: ParameterId, value: &VarInt);
    method put_parameter (line 82) | fn put_parameter(&mut self, id: ParameterId, value: &ParameterValue) {
    method put_bytes_parameter (line 100) | fn put_bytes_parameter(&mut self, id: ParameterId, bytes: &Bytes) {
    method put_cid_parameter (line 106) | fn put_cid_parameter(&mut self, id: ParameterId, cid: &ConnectionId) {
    method put_bool_parameter (line 111) | fn put_bool_parameter(&mut self, id: ParameterId) {
    method put_preferred_address_parameter (line 116) | fn put_preferred_address_parameter(&mut self, id: ParameterId, addr: &...
    method put_reset_token_parameter (line 122) | fn put_reset_token_parameter(&mut self, id: ParameterId, token: &Reset...
    method put_varint_parameter (line 128) | fn put_varint_parameter(&mut self, id: ParameterId, value: &VarInt) {
  type WriteParameters (line 135) | pub trait WriteParameters<Role> {
    method put_parameters (line 136) | fn put_parameters(&mut self, params: &Parameters<Role>);
  method put_parameters (line 140) | fn put_parameters(&mut self, params: &Parameters<Role>) {
  function handle_nom_error (line 147) | fn handle_nom_error<F: Debug, E: Debug>(input: &[u8], nom_error: nom::Er...
  function parse_from_bytes (line 156) | pub fn parse_from_bytes(mut buf: &[u8]) -> Result<Self, QuicError> {
  method try_from_remembered_bytes (line 189) | pub fn try_from_remembered_bytes(mut buf: &[u8]) -> Result<Self, QuicErr...

FILE: qbase/src/param/preferred_address.rs
  type PreferredAddress (line 18) | pub struct PreferredAddress {
    method new (line 31) | pub fn new(
    method encoding_size (line 46) | pub fn encoding_size(&self) -> usize {
  function be_preferred_address (line 53) | pub fn be_preferred_address(input: &[u8]) -> nom::IResult<&[u8], Preferr...
  type WirtePreferredAddress (line 88) | pub trait WirtePreferredAddress: bytes::BufMut {
    method put_preferred_address (line 90) | fn put_preferred_address(&mut self, addr: &PreferredAddress);
    method put_preferred_address (line 94) | fn put_preferred_address(&mut self, addr: &PreferredAddress) {

FILE: qbase/src/role.rs
  type Role (line 35) | pub enum Role {
    method fmt (line 43) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 52) | type Output = Self;
    method not (line 53) | fn not(self) -> Self {
    method from (line 74) | fn from(_: Client) -> Self {
    method from (line 95) | fn from(_: Server) -> Self {
  type IntoRole (line 61) | pub trait IntoRole {
    method into_role (line 63) | fn into_role() -> Role;
    method into_role (line 80) | fn into_role() -> Role {
    method into_role (line 101) | fn into_role() -> Role {
  type RequiredParameters (line 66) | pub trait RequiredParameters {
    method required_parameters (line 67) | fn required_parameters() -> impl IntoIterator<Item = ParameterId>;
    method required_parameters (line 86) | fn required_parameters() -> impl IntoIterator<Item = ParameterId> {
    method required_parameters (line 107) | fn required_parameters() -> impl IntoIterator<Item = ParameterId> {
  type Client (line 71) | pub struct Client;
  type Server (line 92) | pub struct Server;

FILE: qbase/src/sid.rs
  type Dir (line 26) | pub enum Dir {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type StreamId (line 53) | pub struct StreamId(u64);
    method new (line 69) | pub fn new(role: Role, dir: Dir, id: u64) -> Self {
    method role (line 75) | pub fn role(&self) -> Role {
    method dir (line 84) | pub fn dir(&self) -> Dir {
    method id (line 89) | pub fn id(&self) -> u64 {
    method next_unchecked (line 93) | unsafe fn next_unchecked(&self) -> Self {
    method encoding_size (line 98) | pub fn encoding_size(&self) -> usize {
    method fmt (line 104) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 116) | fn from(v: VarInt) -> Self {
  constant MAX_STREAMS_LIMIT (line 61) | pub const MAX_STREAMS_LIMIT: u64 = (1 << 60) - 1;
  method from (line 122) | fn from(s: StreamId) -> Self {
  function from (line 128) | fn from(s: StreamId) -> Self {
  function be_streamid (line 135) | pub fn be_streamid(input: &[u8]) -> nom::IResult<&[u8], StreamId> {
  type WriteStreamId (line 141) | pub trait WriteStreamId: bytes::BufMut {
    method put_streamid (line 143) | fn put_streamid(&mut self, stream_id: &StreamId);
    method put_streamid (line 147) | fn put_streamid(&mut self, stream_id: &StreamId) {
  type ControlStreamsConcurrency (line 166) | pub trait ControlStreamsConcurrency: fmt::Debug + Send + Sync {
    method on_accept_streams (line 175) | fn on_accept_streams(&mut self, dir: Dir, sid: u64) -> Option<u64>;
    method on_end_of_stream (line 186) | fn on_end_of_stream(&mut self, dir: Dir, sid: u64) -> Option<u64>;
    method on_streams_blocked (line 195) | fn on_streams_blocked(&mut self, dir: Dir, max_streams: u64) -> Option...
    method on_accept_streams (line 199) | fn on_accept_streams(&mut self, dir: Dir, sid: u64) -> Option<u64> {
    method on_end_of_stream (line 203) | fn on_end_of_stream(&mut self, dir: Dir, sid: u64) -> Option<u64> {
    method on_streams_blocked (line 207) | fn on_streams_blocked(&mut self, dir: Dir, max_streams: u64) -> Option...
  type ProductStreamsConcurrencyController (line 212) | pub trait ProductStreamsConcurrencyController: Send + Sync {
    method init (line 213) | fn init(
    method init (line 226) | fn init(
  type StreamIds (line 246) | pub struct StreamIds<BLOCKED, MAX> {
  function new (line 263) | pub fn new(

FILE: qbase/src/sid/handy.rs
  type ConsistentConcurrency (line 6) | pub struct ConsistentConcurrency {
    method new (line 11) | pub fn new(initial_max_bi: u64, initial_max_uni: u64) -> Self {
  method on_accept_streams (line 19) | fn on_accept_streams(&mut self, _dir: Dir, _sid: u64) -> Option<u64> {
  method on_end_of_stream (line 23) | fn on_end_of_stream(&mut self, dir: Dir, _sid: u64) -> Option<u64> {
  method on_streams_blocked (line 31) | fn on_streams_blocked(&mut self, _dir: Dir, _max_streams: u64) -> Option...
  type DemandConcurrency (line 39) | pub struct DemandConcurrency;
  method on_accept_streams (line 42) | fn on_accept_streams(&mut self, _dir: Dir, _sid: u64) -> Option<u64> {
  method on_end_of_stream (line 46) | fn on_end_of_stream(&mut self, _dir: Dir, _sid: u64) -> Option<u64> {
  method on_streams_blocked (line 50) | fn on_streams_blocked(&mut self, _dir: Dir, max_streams: u64) -> Option<...

FILE: qbase/src/sid/local_sid.rs
  type LocalStreamIds (line 20) | struct LocalStreamIds<BLOCKED> {
  function new (line 38) | fn new(
  function role (line 60) | fn role(&self) -> Role {
  function opened_streams (line 65) | fn opened_streams(&self, dir: Dir) -> u64 {
  function recv_max_streams_frame (line 71) | fn recv_max_streams_frame(&mut self, frame: MaxStreamsFrame) {
  function increase_limit (line 79) | fn increase_limit(&mut self, dir: Dir, val: u64) {
  function poll_alloc_sid (line 95) | fn poll_alloc_sid(&mut self, cx: &mut Context<'_>, dir: Dir) -> Poll<Opt...
  function revise_max_streams (line 116) | pub fn revise_max_streams(
  type ArcLocalStreamIds (line 141) | pub struct ArcLocalStreamIds<BLOCKED>(Arc<Mutex<LocalStreamIds<BLOCKED>>>);
  function new (line 150) | pub fn new(
  function role (line 163) | pub fn role(&self) -> Role {
  function opened_streams (line 174) | pub fn opened_streams(&self, dir: Dir) -> u64 {
  function recv_max_streams_frame (line 185) | pub fn recv_max_streams_frame(&self, frame: MaxStreamsFrame) {
  function poll_alloc_sid (line 208) | pub fn poll_alloc_sid(&self, cx: &mut Context<'_>, dir: Dir) -> Poll<Opt...
  function revise_max_streams (line 212) | pub fn revise_max_streams(
  type Output (line 230) | type Output = ();
  function recv_frame (line 232) | fn recv_frame(&self, frame: MaxStreamsFrame) -> Result<Self::Output, cra...
  type StreamsBlockedFrameTx (line 246) | struct StreamsBlockedFrameTx(ArcAsyncDeque<StreamsBlockedFrame>);
    method send_frame (line 249) | fn send_frame<I: IntoIterator<Item = StreamsBlockedFrame>>(&self, iter...
  function test_stream_id_new (line 255) | fn test_stream_id_new() {
  function test_recv_max_stream_frames (line 263) | fn test_recv_max_stream_frames() {

FILE: qbase/src/sid/remote_sid.rs
  type ExceedLimitError (line 21) | pub struct ExceedLimitError(StreamId, u64);
  type AcceptSid (line 26) | pub enum AcceptSid {
  type NeedCreate (line 37) | pub struct NeedCreate {
  type Item (line 43) | type Item = StreamId;
  method next (line 44) | fn next(&mut self) -> Option<Self::Item> {
  type RemoteStreamIds (line 58) | struct RemoteStreamIds<MAX> {
  function new (line 72) | fn new(
  function role (line 92) | fn role(&self) -> Role {
  function try_accept_sid (line 96) | fn try_accept_sid(&mut self, sid: StreamId) -> Result<AcceptSid, ExceedL...
  function on_end_of_stream (line 120) | fn on_end_of_stream(&mut self, sid: StreamId) {
  function recv_streams_blocked_frame (line 134) | fn recv_streams_blocked_frame(&mut self, frame: StreamsBlockedFrame) {
  type ArcRemoteStreamIds (line 166) | pub struct ArcRemoteStreamIds<MAX>(Arc<Mutex<RemoteStreamIds<MAX>>>);
  function new (line 181) | pub fn new(
  function role (line 194) | pub fn role(&self) -> Role {
  function try_accept_sid (line 215) | pub fn try_accept_sid(&self, sid: StreamId) -> Result<AcceptSid, ExceedL...
  function on_end_of_stream (line 220) | pub fn on_end_of_stream(&self, sid: StreamId) {
  function recv_streams_blocked_frame (line 225) | pub fn recv_streams_blocked_frame(&self, frame: StreamsBlockedFrame) {
  type Output (line 234) | type Output = ();
  function recv_frame (line 236) | fn recv_frame(&self, frame: StreamsBlockedFrame) -> Result<Self::Output,...
  type MaxStreamsFrameTx (line 250) | struct MaxStreamsFrameTx(ArcAsyncDeque<MaxStreamsFrame>);
    method send_frame (line 253) | fn send_frame<I: IntoIterator<Item = MaxStreamsFrame>>(&self, iter: I) {
  function test_try_accept_sid (line 259) | fn test_try_accept_sid() {

FILE: qbase/src/time.rs
  type TimeOut (line 10) | pub struct TimeOut;
  type IdleConfig (line 13) | pub struct IdleConfig {
    method suitable_heartbeat_interval (line 20) | fn suitable_heartbeat_interval(max_idle_timeout: Duration) -> Duration {
    method new (line 31) | pub fn new(max_idle_timeout: Duration, defer_idle_timeout: Duration) -...
    method negotiate_max_idle_timeout (line 45) | pub fn negotiate_max_idle_timeout(&mut self, max_idle_timeout: Duratio...
    method set_heartbeat_interval (line 55) | pub fn set_heartbeat_interval(&mut self, interval: Duration) {
  type ArcIdleConfig (line 61) | pub struct ArcIdleConfig(Arc<RwLock<IdleConfig>>);
    method new (line 65) | pub fn new(max_idle_timeout: Duration, defer_idle_timeout: Duration) -...
    method negotiate_max_idle_timeout (line 77) | pub fn negotiate_max_idle_timeout(&self, max_idle_timeout: Duration) {
    method set_heartbeat_interval (line 85) | pub fn set_heartbeat_interval(&self, interval: Duration) {
    method timer (line 89) | pub fn timer(&self) -> ArcIdleTimer {
    method defer_idle_timeout (line 98) | fn defer_idle_timeout(&self) -> Duration {
    method heartbeat_interval (line 102) | fn heartbeat_interval(&self) -> Duration {
    method timeout_after (line 106) | fn timeout_after(&self, idle_at: Instant) -> bool {
  type IdleTimer (line 115) | pub struct IdleTimer {
    method on_sent (line 124) | pub fn on_sent(&mut self, packet_content: PacketContent) {
    method on_rcvd (line 133) | pub fn on_rcvd(&mut self, packet_content: PacketContent) {
    method health (line 146) | pub fn health(&mut self) -> Result<Option<PingFrame>, TimeOut> {
  type ArcIdleTimer (line 172) | pub struct ArcIdleTimer(Arc<Mutex<IdleTimer>>);
    method on_sent (line 176) | pub fn on_sent(&self, packet_content: PacketContent) {
    method on_rcvd (line 181) | pub fn on_rcvd(&self, packet_content: PacketContent) {
    method health (line 187) | pub fn health(&self) -> Result<Option<PingFrame>, TimeOut> {

FILE: qbase/src/token.rs
  constant RESET_TOKEN_SIZE (line 13) | pub const RESET_TOKEN_SIZE: usize = 16;
  type ResetToken (line 16) | pub struct ResetToken([u8; RESET_TOKEN_SIZE]);
    method new (line 19) | pub fn new(bytes: &[u8]) -> Self {
    method random_gen (line 23) | pub fn random_gen() -> Self {
    method encoding_size (line 29) | pub fn encoding_size(&self) -> usize {
  function be_reset_token (line 34) | pub fn be_reset_token(input: &[u8]) -> IResult<&[u8], ResetToken> {
  type WriteResetToken (line 39) | pub trait WriteResetToken {
    method put_reset_token (line 40) | fn put_reset_token(&mut self, token: &ResetToken);
    method put_reset_token (line 44) | fn put_reset_token(&mut self, token: &ResetToken) {
  type TokenSink (line 49) | pub trait TokenSink: Send + Sync {
    method sink (line 50) | fn sink(&self, server_name: &str, token: Vec<u8>);
    method fetch_token (line 52) | fn fetch_token(&self, server_name: &str) -> Vec<u8>;
  type TokenProvider (line 55) | pub trait TokenProvider: Send + Sync {
    method gen_new_token (line 56) | fn gen_new_token(&self, server_name: &str) -> Vec<u8>;
    method gen_retry_token (line 58) | fn gen_retry_token(&self, server_name: &str) -> Vec<u8>;
    method verify_token (line 62) | fn verify_token(&self, server_name: &str, token: &[u8]) -> bool;
  type TokenRegistry (line 65) | pub enum TokenRegistry {
  type ArcTokenRegistry (line 71) | pub struct ArcTokenRegistry(Arc<TokenRegistry>);
    method with_sink (line 74) | pub fn with_sink(server_name: String, sink: Arc<dyn TokenSink>) -> Self {
    method with_provider (line 78) | pub fn with_provider(provider: Arc<dyn TokenProvider>) -> Self {
    type Output (line 92) | type Output = ();
    method recv_frame (line 94) | fn recv_frame(&self, frame: NewTokenFrame) -> Result<Self::Output, cra...
  type Target (line 84) | type Target = TokenRegistry;
  method deref (line 86) | fn deref(&self) -> &Self::Target {
  type NoopTokenRegistry (line 111) | pub struct NoopTokenRegistry;
    method sink (line 114) | fn sink(&self, _: &str, _: Vec<u8>) {}
    method fetch_token (line 116) | fn fetch_token(&self, _: &str) -> Vec<u8> {
    method gen_new_token (line 122) | fn gen_new_token(&self, _: &str) -> Vec<u8> {
    method gen_retry_token (line 126) | fn gen_retry_token(&self, _: &str) -> Vec<u8> {
    method verify_token (line 130) | fn verify_token(&self, _: &str, _: &[u8]) -> bool {
  function test_create_token (line 139) | fn test_create_token() {
  function test_creat_token_with_less_size (line 145) | fn test_creat_token_with_less_size() {
  function test_creat_token_with_more_size (line 151) | fn test_creat_token_with_more_size() {
  function test_read_reset_token (line 156) | fn test_read_reset_token() {
  function test_write_reset_token (line 171) | fn test_write_reset_token() {

FILE: qbase/src/util/async_deque.rs
  type AsyncDeque (line 17) | struct AsyncDeque<T> {
  function push_back (line 25) | fn push_back(&mut self, value: T) {
  function push_front (line 36) | fn push_front(&mut self, value: T) {
  function poll_pop (line 52) | fn poll_pop(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
  function len (line 77) | fn len(&self) -> usize {
  function is_empty (line 82) | fn is_empty(&self) -> bool {
  function close (line 93) | pub fn close(&mut self) {
  function extend (line 102) | fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
  type ArcAsyncDeque (line 120) | pub struct ArcAsyncDeque<T>(Arc<Mutex<AsyncDeque<T>>>);
  function new (line 124) | pub fn new() -> Self {
  function with_capacity (line 132) | pub fn with_capacity(capacity: usize) -> Self {
  function lock_guard (line 139) | fn lock_guard(&self) -> MutexGuard<'_, AsyncDeque<T>> {
  function push_front (line 156) | pub fn push_front(&self, value: T) {
  function push_back (line 173) | pub fn push_back(&self, value: T) {
  function pop (line 204) | pub fn pop(&self) -> Self {
  function poll_pop (line 231) | pub fn poll_pop(&self, cx: &mut Context<'_>) -> Poll<Option<T>> {
  function len (line 236) | pub fn len(&self) -> usize {
  function is_empty (line 253) | pub fn is_empty(&self) -> bool {
  function close (line 284) | pub fn close(&self) {
  method default (line 290) | fn default() -> Self {
  method clone (line 296) | fn clone(&self) -> Self {
  type Output (line 302) | type Output = Option<T>;
  method poll (line 304) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Item (line 310) | type Item = T;
  function poll_next (line 312) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  function extend (line 318) | fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
  function push_pop (line 330) | async fn push_pop() {
  function close (line 349) | async fn close() {
  function wake (line 363) | async fn wake() {
  function cancel (line 388) | async fn cancel() {
  function racing (line 410) | async fn racing() {

FILE: qbase/src/util/bound_queue.rs
  type BoundQueueInner (line 10) | struct BoundQueueInner<T> {
  type BoundQueue (line 16) | pub struct BoundQueue<T>(Arc<BoundQueueInner<T>>);
  method clone (line 19) | fn clone(&self) -> Self {
  function new (line 26) | pub fn new(size: usize) -> Self {
  function try_send (line 32) | pub fn try_send(&self, item: T) -> Result<(), mpsc::TrySendError<T>> {
  function send (line 37) | pub async fn send(&self, item: T) -> Result<(), mpsc::SendError> {
  function recv (line 42) | pub async fn recv(&self) -> Option<T> {
  function close (line 47) | pub fn close(&self) {
  function is_closed (line 52) | pub fn is_closed(&self) -> bool {
  function same_queue (line 57) | pub fn same_queue(&self, other: &Self) -> bool {
  function test_send_receive (line 68) | async fn test_send_receive() {

FILE: qbase/src/util/data.rs
  type ContinuousData (line 3) | pub trait ContinuousData {
    method len (line 4) | fn len(&self) -> usize;
    method is_empty (line 6) | fn is_empty(&self) -> bool;
    method to_bytes (line 8) | fn to_bytes(&self) -> Bytes;
    method len (line 15) | fn len(&self) -> usize {
    method is_empty (line 20) | fn is_empty(&self) -> bool {
    method to_bytes (line 25) | fn to_bytes(&self) -> Bytes {
    method len (line 32) | fn len(&self) -> usize {
    method is_empty (line 37) | fn is_empty(&self) -> bool {
    method to_bytes (line 42) | fn to_bytes(&self) -> Bytes {
    method len (line 49) | fn len(&self) -> usize {
    method is_empty (line 54) | fn is_empty(&self) -> bool {
    method to_bytes (line 59) | fn to_bytes(&self) -> Bytes {
    method len (line 66) | fn len(&self) -> usize {
    method is_empty (line 71) | fn is_empty(&self) -> bool {
    method to_bytes (line 76) | fn to_bytes(&self) -> Bytes {
    method len (line 83) | fn len(&self) -> usize {
    method is_empty (line 88) | fn is_empty(&self) -> bool {
    method to_bytes (line 93) | fn to_bytes(&self) -> Bytes {
    method len (line 102) | fn len(&self) -> usize {
    method is_empty (line 107) | fn is_empty(&self) -> bool {
    method to_bytes (line 112) | fn to_bytes(&self) -> Bytes {
    method len (line 119) | fn len(&self) -> usize {
    method is_empty (line 124) | fn is_empty(&self) -> bool {
    method to_bytes (line 129) | fn to_bytes(&self) -> Bytes {
    method len (line 136) | fn len(&self) -> usize {
    method is_empty (line 141) | fn is_empty(&self) -> bool {
    method to_bytes (line 146) | fn to_bytes(&self) -> Bytes {
    method len (line 158) | fn len(&self) -> usize {
    method is_empty (line 163) | fn is_empty(&self) -> bool {
    method to_bytes (line 168) | fn to_bytes(&self) -> Bytes {
  type DataPair (line 11) | pub type DataPair<'a> = (&'a [u8], &'a [u8]);
  type NonData (line 98) | pub type NonData = ();
  type WriteData (line 173) | pub trait WriteData<D: ContinuousData + ?Sized>: BufMut {
    method put_data (line 174) | fn put_data(&mut self, data: &D);
  method put_data (line 179) | fn put_data(&mut self, data: &DataPair<'_>) {
  method put_data (line 187) | fn put_data(&mut self, data: &[u8]) {
  method put_data (line 194) | fn put_data(&mut self, data: &[u8; N]) {
  method put_data (line 201) | fn put_data(&mut self, data: &Bytes) {
  method put_data (line 208) | fn put_data(&mut self, &(): &()) {}
  method put_data (line 216) | fn put_data(&mut self, data: &&D) {
  method put_data (line 226) | fn put_data(&mut self, data: &[D]) {
  method put_data (line 238) | fn put_data(&mut self, data: &[D; N]) {

FILE: qbase/src/util/index_deque.rs
  type IndexError (line 10) | pub enum IndexError {
  type IndexDeque (line 30) | pub struct IndexDeque<T, const LIMIT: u64> {
  method default (line 36) | fn default() -> Self {
  function with_capacity (line 54) | pub fn with_capacity(capacity: usize) -> Self {
  function is_empty (line 73) | pub fn is_empty(&self) -> bool {
  function len (line 89) | pub fn len(&self) -> usize {
  function offset (line 107) | pub fn offset(&self) -> u64 {
  function largest (line 123) | pub fn largest(&self) -> u64 {
  function contain (line 140) | pub fn contain(&self, idx: u64) -> bool {
  function get (line 158) | pub fn get(&self, idx: u64) -> Option<&T> {
  function get_mut (line 183) | pub fn get_mut(&mut self, idx: u64) -> Option<&mut T> {
  function push_back (line 205) | pub fn push_back(&mut self, value: T) -> Result<u64, IndexError> {
  function pop_front (line 230) | pub fn pop_front(&mut self) -> Option<(u64, T)> {
  function front (line 238) | pub fn front(&self) -> Option<(u64, &T)> {
  function back (line 242) | pub fn back(&self) -> Option<(u64, &T)> {
  function iter (line 261) | pub fn iter(&self) -> impl DoubleEndedIterator<Item = &T> {
  function iter_mut (line 282) | pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> {
  function enumerate (line 301) | pub fn enumerate(&self) -> impl DoubleEndedIterator<Item = (u64, &T)> {
  function enumerate_mut (line 326) | pub fn enumerate_mut(&mut self) -> impl DoubleEndedIterator<Item = (u64,...
  function advance (line 351) | pub fn advance(&mut self, n: usize) {
  function drain_to (line 372) | pub fn drain_to(&mut self, end: u64) -> impl DoubleEndedIterator<Item = ...
  function reset_offset (line 400) | pub fn reset_offset(&mut self, new_offset: u64) {
  function extend (line 407) | fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
  function insert (line 436) | pub fn insert(&mut self, idx: u64, value: T) -> Result<Option<T>, IndexE...
  function resize (line 457) | pub fn resize(&mut self, new_end: u64, value: T) -> Result<(), IndexErro...
  type Output (line 471) | type Output = T;
  function index (line 473) | fn index(&self, index: u64) -> &Self::Output {
  function index_mut (line 479) | fn index_mut(&mut self, index: u64) -> &mut Self::Output {
  function test_index_queue (line 489) | fn test_index_queue() {
  function test_insert (line 534) | fn test_insert() {
  function test_skip (line 547) | fn test_skip() {
  function test_reset_offset (line 563) | fn test_reset_offset() {
  function test_reset_offset_with_content (line 576) | fn test_reset_offset_with_content() {
  function test_reset_offset_panic2 (line 588) | fn test_reset_offset_panic2() {
  function test_resize (line 604) | fn test_resize() {

FILE: qbase/src/util/unique_id.rs
  type UniqueId (line 10) | pub struct UniqueId(usize);
  type UniqueIdGenerator (line 14) | pub struct UniqueIdGenerator(AtomicUsize);
    method new (line 35) | pub const fn new() -> Self {
    method generate (line 51) | pub fn generate(&self) -> UniqueId {
  method default (line 17) | fn default() -> Self {
  function test_unique_id_basic (line 65) | fn test_unique_id_basic() {
  function test_unique_id_hash (line 76) | fn test_unique_id_hash() {
  function test_unique_id_clone_copy (line 89) | fn test_unique_id_clone_copy() {
  function test_thread_safety (line 98) | fn test_thread_safety() {
  function test_default_generator (line 129) | fn test_default_generator() {

FILE: qbase/src/util/wakers.rs
  type WakerVec (line 11) | pub struct WakerVec<const N: usize = 4> {
  method default (line 16) | fn default() -> Self {
  function new (line 22) | pub const fn new() -> Self {
  function register (line 28) | pub fn register(&mut self, waker: &Waker) {
  function wake_all (line 34) | pub fn wake_all(&mut self) {
  method drop (line 42) | fn drop(&mut self) {
  type Wakers (line 48) | pub struct Wakers<const N: usize = 4> {
  method wake (line 53) | fn wake(self: Arc<Self>) {
  method wake_by_ref (line 57) | fn wake_by_ref(self: &Arc<Self>) {
  method default (line 63) | fn default() -> Self {
  function new (line 69) | pub const fn new() -> Self {
  function lock (line 75) | fn lock(&self) -> MutexGuard<'_, WakerVec<N>> {
  function register (line 79) | pub fn register(&self, waker: &Waker) {
  function wake_all (line 83) | pub fn wake_all(&self) {
  function to_waker (line 87) | pub fn to_waker(self: &Arc<Self>) -> Waker {
  function combine_with (line 91) | pub fn combine_with<T>(

FILE: qbase/src/varint.rs
  type VarInt (line 12) | pub struct VarInt(u64);
    constant MAX (line 30) | pub const MAX: Self = Self(VARINT_MAX);
    constant MAX_SIZE (line 32) | pub const MAX_SIZE: usize = 8;
    method from_u32 (line 35) | pub const fn from_u32(x: u32) -> Self {
    method from_u64 (line 41) | pub const fn from_u64(x: u64) -> Result<Self, err::Overflow> {
    method from_u64_unchecked (line 54) | pub unsafe fn from_u64_unchecked(x: u64) -> Self {
    method from_u128 (line 60) | pub fn from_u128(x: u128) -> Result<Self, err::Overflow> {
    method into_u64 (line 69) | pub fn into_u64(self) -> u64 {
    method encoding_size (line 74) | pub fn encoding_size(self) -> usize {
    method from (line 97) | fn from(x: u8) -> Self {
    method from (line 103) | fn from(x: u16) -> Self {
    method from (line 109) | fn from(x: u32) -> Self {
    type Error (line 115) | type Error = err::Overflow;
    method try_from (line 117) | fn try_from(x: u128) -> Result<Self, Self::Error> {
    type Error (line 123) | type Error = err::Overflow;
    method try_from (line 126) | fn try_from(x: u64) -> Result<Self, Self::Error> {
    type Error (line 132) | type Error = err::Overflow;
    method try_from (line 135) | fn try_from(x: usize) -> Result<Self, Self::Error> {
    method to_usize (line 141) | fn to_usize(&self) -> usize {
    method eq (line 147) | fn eq(&self, other: &u64) -> bool {
    method partial_cmp (line 153) | fn partial_cmp(&self, other: &u64) -> Option<Ordering> {
    method fmt (line 159) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant VARINT_MAX (line 15) | pub const VARINT_MAX: u64 = 0x3fff_ffff_ffff_ffff;
  type EncodeBytes (line 21) | pub enum EncodeBytes {
  function from (line 91) | fn from(x: VarInt) -> Self {
  type Overflow (line 173) | pub struct Overflow(pub(super) u128);
  function be_varint (line 190) | pub fn be_varint(input: &[u8]) -> IResult<&[u8], VarInt> {
  type WriteVarInt (line 205) | pub trait WriteVarInt: BufMut {
    method put_varint (line 230) | fn put_varint(&mut self, value: &VarInt);
    method encode_varint (line 233) | fn encode_varint(&mut self, value: &VarInt, nbytes: EncodeBytes);
    method put_varint (line 238) | fn put_varint(&mut self, value: &VarInt) {
    method encode_varint (line 253) | fn encode_varint(&mut self, value: &VarInt, nbytes: EncodeBytes) {
  function test_equal (line 280) | fn test_equal() {
  function test_be_varint (line 288) | fn test_be_varint() {
  function assert_put_varint_eq (line 316) | fn assert_put_varint_eq(val: u64, expected: &[u8]) {
  function test_put_varint (line 324) | fn test_put_varint() {
  function test_encode_varint (line 342) | fn test_encode_varint() {

FILE: qcongestion/src/algorithm.rs
  type Algorithm (line 10) | pub enum Algorithm {
  type Control (line 15) | pub trait Control: Send {
    method on_packet_sent_cc (line 16) | fn on_packet_sent_cc(&mut self, packet: &SentPacket);
    method on_packet_acked (line 18) | fn on_packet_acked(&mut self, acked_packet: &SentPacket);
    method on_packets_lost (line 20) | fn on_packets_lost(
    method process_ecn (line 26) | fn process_ecn(&mut self, ack: &AckFrame, sent_time: &Instant, epoch: ...
    method congestion_window (line 28) | fn congestion_window(&self) -> usize;
    method pacing_rate (line 30) | fn pacing_rate(&self) -> Option<usize>;
    method remove_from_bytes_in_flight (line 32) | fn remove_from_bytes_in_flight(&mut self, packets: &mut dyn Iterator<I...

FILE: qcongestion/src/algorithm/bbr.rs
  constant MSS (line 19) | const MSS: usize = 1200;
  constant RTPROP_FILTER_LEN (line 22) | const RTPROP_FILTER_LEN: Duration = Duration::from_secs(10);
  constant HIGH_GAIN (line 27) | const HIGH_GAIN: f64 = 2.89;
  constant PROBE_RTT_DURATION (line 32) | const PROBE_RTT_DURATION: Duration = Duration::from_millis(200);
  constant SEND_QUANTUM_THRESHOLD_PACING_RATE (line 35) | const SEND_QUANTUM_THRESHOLD_PACING_RATE: u64 = 1_200_000 / 8;
  constant INITIAL_CWND (line 38) | pub(crate) const INITIAL_CWND: u64 = 80 * MSS as u64;
  constant MIN_PIPE_CWND_PKTS (line 41) | const MIN_PIPE_CWND_PKTS: usize = 4;
  constant MINIMUM_WINDOW_PACKETS (line 43) | const MINIMUM_WINDOW_PACKETS: usize = 2;
  type BbrStateMachine (line 49) | enum BbrStateMachine {
  type Bbr (line 56) | pub(crate) struct Bbr {
    method new (line 166) | pub fn new() -> Self {
    method on_connection_init (line 239) | fn on_connection_init(&mut self) {
    method update_model_and_state (line 244) | fn update_model_and_state(&mut self, ack: &mut AckedPackets) {
    method update_control_parameters (line 253) | fn update_control_parameters(&mut self) {
    method on_transmit (line 260) | fn on_transmit(&mut self) {
  method from (line 148) | fn from(value: &Bbr) -> Self {
  method on_packet_sent_cc (line 212) | fn on_packet_sent_cc(&mut self, packet: &crate::packets::SentPacket) {
  method on_packet_acked (line 216) | fn on_packet_acked(&mut self, acked_packet: &crate::packets::SentPacket) {
  method on_packets_lost (line 220) | fn on_packets_lost(&mut self, lost_packets: &[crate::packets::SentPacket...
  method on_congestion_event (line 224) | fn on_congestion_event(&mut self, sent_time: &Instant) {
  method congestion_window (line 228) | fn congestion_window(&self) -> usize {
  method pacing_rate (line 232) | fn pacing_rate(&self) -> Option<usize> {
  function test_bbr_init (line 279) | fn test_bbr_init() {
  function test_bbr_sent (line 295) | fn test_bbr_sent() {
  function test_bbr_ack (line 308) | fn test_bbr_ack() {
  function simulate_round_trip (line 347) | pub(super) fn simulate_round_trip(

FILE: qcongestion/src/algorithm/bbr/delivery_rate.rs
  type Rate (line 8) | pub struct Rate {
    method on_packet_sent (line 40) | pub fn on_packet_sent(
    method update_rate_sample (line 63) | pub fn update_rate_sample(&mut self, pkt: &AckedPackets, now: Instant) {
    method generate_rate_sample (line 85) | pub fn generate_rate_sample(&mut self) {
    method update_app_limited (line 110) | pub fn update_app_limited(&mut self, v: bool) {
    method app_limited (line 114) | pub fn app_limited(&mut self) -> bool {
    method delivered (line 118) | pub fn delivered(&self) -> usize {
    method sample_delivery_rate (line 122) | pub fn sample_delivery_rate(&self) -> u64 {
    method sample_rtt (line 126) | pub fn sample_rtt(&self) -> Duration {
    method sample_is_app_limited (line 130) | pub fn sample_is_app_limited(&self) -> bool {
  method default (line 23) | fn default() -> Self {
  type RateSample (line 136) | struct RateSample {
  function test_rate (line 153) | fn test_rate() {

FILE: qcongestion/src/algorithm/bbr/min_max.rs
  type MinMax (line 4) | pub(super) struct MinMax {
    method fill (line 11) | fn fill(&mut self, sample: MinMaxSample) {
    method update_max (line 15) | pub(super) fn update_max(&mut self, current_round: u64, measurement: u...
    method subwin_update (line 41) | fn subwin_update(&mut self, sample: MinMaxSample) {
  method default (line 77) | fn default() -> Self {
  type MinMaxSample (line 86) | struct MinMaxSample {

FILE: qcongestion/src/algorithm/bbr/model.rs
  method init_round_counting (line 11) | pub(super) fn init_round_counting(&mut self) {
  method update_round (line 18) | fn update_round(&mut self, packet: &AckedPackets) {
  method update_btlbw (line 30) | pub(super) fn update_btlbw(&mut self, packet: &AckedPackets) {
  method update_rtprop (line 43) | pub(super) fn update_rtprop(&mut self) {

FILE: qcongestion/src/algorithm/bbr/parameters.rs
  method init_pacing_rate (line 15) | pub(super) fn init_pacing_rate(&mut self) {
  method set_pacing_rate (line 21) | pub(super) fn set_pacing_rate(&mut self) {
  method set_pacing_rate_with_gain (line 25) | pub(super) fn set_pacing_rate_with_gain(&mut self, pacing_gain: f64) {
  method set_send_quantum (line 33) | pub(super) fn set_send_quantum(&mut self) {
  method inflight (line 46) | pub fn inflight(&self, gain: f64) -> u64 {
  method update_target_cwnd (line 56) | fn update_target_cwnd(&mut self) {
  method save_cwnd (line 61) | pub(super) fn save_cwnd(&mut self) {
  method restore_cwnd (line 69) | pub fn restore_cwnd(&mut self) {
  method modulate_cwnd_for_recovery (line 73) | fn modulate_cwnd_for_recovery(&mut self, bytes_in_flight: u64) {
  method modulate_cwnd_for_probe_rtt (line 87) | fn modulate_cwnd_for_probe_rtt(&mut self) {
  method set_cwnd (line 94) | pub(super) fn set_cwnd(&mut self) {
  method min_pipe_cwnd (line 115) | pub(super) fn min_pipe_cwnd(&self) -> u64 {
  function test_init_pacing_rate (line 126) | fn test_init_pacing_rate() {
  function test_bbr_set_pacing_rate (line 136) | fn test_bbr_set_pacing_rate() {
  function test_bbr_set_send_quantum (line 145) | fn test_bbr_set_send_quantum() {
  function test_bbr_inflight (line 166) | fn test_bbr_inflight() {
  function test_bbr_modulate_cwnd_for_recovery (line 180) | fn test_bbr_modulate_cwnd_for_recovery() {
  function test_modulate_cwnd_for_probe_rtt (line 201) | fn test_modulate_cwnd_for_probe_rtt() {
  function test_bbr_set_cwnd (line 212) | fn test_bbr_set_cwnd() {

FILE: qcongestion/src/algorithm/bbr/state.rs
  constant GAIN_CYCLE_LEN (line 7) | const GAIN_CYCLE_LEN: usize = 8;
  constant PACING_GAIN_CYCLE (line 10) | const PACING_GAIN_CYCLE: [f64; GAIN_CYCLE_LEN] = [1.25, 0.75, 1.0, 1.0, ...
  method init (line 13) | pub(super) fn init(&mut self) {
  method enter_startup (line 29) | pub(crate) fn enter_startup(&mut self) {
  method init_full_pipe (line 36) | fn init_full_pipe(&mut self) {
  method check_full_pipe (line 43) | pub(super) fn check_full_pipe(&mut self) {
  method enter_drain (line 63) | fn enter_drain(&mut self) {
  method check_drain (line 69) | pub(super) fn check_drain(&mut self) {
  method enter_probe_bw (line 79) | pub fn enter_probe_bw(&mut self) {
  method check_cycle_phase (line 91) | pub(super) fn check_cycle_phase(&mut self) {
  method advance_cycle_phase (line 97) | fn advance_cycle_phase(&mut self) {
  method is_next_cycle_phase (line 104) | fn is_next_cycle_phase(&mut self) -> bool {
  method handle_restart_from_idle (line 125) | pub(super) fn handle_restart_from_idle(&mut self) {
  method check_probe_rtt (line 136) | pub(super) fn check_probe_rtt(&mut self) {
  method enter_probe_rtt (line 153) | fn enter_probe_rtt(&mut self) {
  method handle_probe_rtt (line 160) | fn handle_probe_rtt(&mut self) {
  method exit_probe_rtt (line 183) | fn exit_probe_rtt(&mut self, _: Instant) {
  function test_bbr_init (line 202) | fn test_bbr_init() {
  function test_bbr_enter_startup (line 212) | fn test_bbr_enter_startup() {
  function test_bbr_check_full_pipe (line 221) | fn test_bbr_check_full_pipe() {
  function test_bbr_check_drain (line 249) | fn test_bbr_check_drain() {
  function test_bbr_enter_probe_bw (line 265) | fn test_bbr_enter_probe_bw() {
  function test_bbr_advance_cycle_phase (line 274) | fn test_bbr_advance_cycle_phase() {
  function test_bbr_is_next_cycle_phase (line 287) | fn test_bbr_is_next_cycle_phase() {
  function test_restart_from_idle (line 308) | fn test_restart_from_idle() {

FILE: qcongestion/src/algorithm/new_reno.rs
  constant INFINITRE_SSTHRESH (line 15) | const INFINITRE_SSTHRESH: usize = usize::MAX;
  type NewReno (line 17) | pub(crate) struct NewReno {
    method new (line 37) | pub(crate) fn new(max_datagram_size: Arc<AtomicU16>) -> Self {
    method on_packet_sent_cc (line 56) | fn on_packet_sent_cc(&mut self, sent_bytes: usize) {
    method in_congestion_recovery (line 63) | fn in_congestion_recovery(&self, sent_time: &Instant) -> bool {
    method on_packet_acked (line 89) | fn on_packet_acked(&mut self, acked_packet: &SentPacket) {
    method on_congestion_event (line 122) | fn on_congestion_event(&mut self, sent_time: &Instant) {
    method process_ecn (line 147) | fn process_ecn(&mut self, ack: &AckFrame, sent_time: &Instant, epoch: ...
    method on_packets_lost (line 180) | fn on_packets_lost(
    method remove_from_bytes_in_flight (line 211) | fn remove_from_bytes_in_flight(
    method max_datagram_size (line 222) | fn max_datagram_size(&self) -> usize {
  method from (line 27) | fn from(reno: &NewReno) -> Self {
  method on_packet_sent_cc (line 228) | fn on_packet_sent_cc(&mut self, packet: &SentPacket) {
  method on_packet_acked (line 232) | fn on_packet_acked(&mut self, acked_packet: &SentPacket) {
  method on_packets_lost (line 236) | fn on_packets_lost(
  method congestion_window (line 244) | fn congestion_window(&self) -> usize {
  method pacing_rate (line 248) | fn pacing_rate(&self) -> Option<usize> {
  method remove_from_bytes_in_flight (line 252) | fn remove_from_bytes_in_flight(&mut self, packets: &mut dyn Iterator<Ite...
  method process_ecn (line 256) | fn process_ecn(&mut self, ack: &AckFrame, sent_time: &Instant, epoch: Ep...

FILE: qcongestion/src/congestion.rs
  constant INIT_CWND (line 20) | const INIT_CWND: usize = MSS * 10;
  constant PACKET_THRESHOLD (line 21) | const PACKET_THRESHOLD: usize = 3;
  type CongestionController (line 25) | pub struct CongestionController {
    method init (line 48) | fn init(
    method on_packet_sent (line 96) | pub fn on_packet_sent(
    method on_datagram_rcvd (line 132) | pub fn on_datagram_rcvd(&mut self) {
    method on_ack_rcvd (line 183) | pub fn on_ack_rcvd(&mut self, epoch: Epoch, ack_frame: &AckFrame, now:...
    method set_loss_detection_timer (line 242) | fn set_loss_detection_timer(&mut self) {
    method on_loss_detection_timeout (line 289) | fn on_loss_detection_timeout(&mut self) -> u32 {
    method get_loss_time_and_epoch (line 334) | fn get_loss_time_and_epoch(&self) -> Option<(Instant, Epoch)> {
    method get_pto_time_and_epoch (line 370) | fn get_pto_time_and_epoch(&self) -> Option<(Instant, Epoch)> {
    method no_ack_eliciting_in_flight (line 406) | fn no_ack_eliciting_in_flight(&self) -> bool {
    method peer_completed_address_validation (line 418) | fn peer_completed_address_validation(&self) -> bool {
    method process_ecn (line 424) | fn process_ecn(&mut self, ack: &AckFrame, sent_time: &Instant, epoch: ...
    method send_ack_eliciting_packet (line 428) | fn send_ack_eliciting_packet(&mut self, epoch: Epoch, count: usize) {
    method need_ack (line 434) | fn need_ack(&self) -> bool {
    method send_quota (line 439) | fn send_quota(&mut self) -> usize {
    method discard_epoch (line 459) | fn discard_epoch(&mut self, epoch: Epoch) {
    method get_pto (line 467) | fn get_pto(&self, epoch: Epoch) -> Duration {
  type ArcCC (line 477) | pub struct ArcCC(Arc<Mutex<CongestionController>>);
    method new (line 480) | pub fn new(
    method do_tick (line 498) | fn do_tick(&self) -> Result<(), TooManyPtos> {
    method send_quota (line 519) | fn send_quota(&self) -> Result<usize, Signals> {
    method retransmit_and_expire_time (line 530) | fn retransmit_and_expire_time(&self, epoch: Epoch) -> (Duration, Durat...
    method need_ack (line 539) | fn need_ack(&self, epoch: Epoch) -> Option<(u64, Instant)> {
    method on_pkt_sent (line 544) | fn on_pkt_sent(
    method on_ack_rcvd (line 567) | fn on_ack_rcvd(&self, epoch: Epoch, ack_frame: &AckFrame) {
    method on_pkt_rcvd (line 578) | fn on_pkt_rcvd(&self, epoch: Epoch, pn: u64, is_ack_eliciting: bool) {
    method get_pto (line 587) | fn get_pto(&self, epoch: Epoch) -> Duration {
    method discard_epoch (line 592) | fn discard_epoch(&self, epoch: Epoch) {
    method need_send_ack_eliciting (line 597) | fn need_send_ack_eliciting(&self, epoch: Epoch) -> usize {
    method grant_anti_amplification (line 602) | fn grant_anti_amplification(&self) {

FILE: qcongestion/src/lib.rs
  constant MSS (line 17) | pub const MSS: usize = 1200;
  type TooManyPtos (line 21) | pub struct TooManyPtos(u32);
  type Transport (line 24) | pub trait Transport {
    method do_tick (line 26) | fn do_tick(&self) -> Result<(), TooManyPtos>;
    method send_quota (line 30) | fn send_quota(&self) -> Result<usize, Signals>;
    method retransmit_and_expire_time (line 33) | fn retransmit_and_expire_time(&self, epoch: Epoch) -> (Duration, Durat...
    method on_pkt_sent (line 42) | fn on_pkt_sent(
    method on_pkt_rcvd (line 56) | fn on_pkt_rcvd(&self, space: Epoch, pn: u64, is_ack_elicition: bool);
    method need_ack (line 61) | fn need_ack(&self, space: Epoch) -> Option<(u64, Instant)>;
    method need_send_ack_eliciting (line 64) | fn need_send_ack_eliciting(&self, space: Epoch) -> usize;
    method on_ack_rcvd (line 67) | fn on_ack_rcvd(&self, space: Epoch, ack_frame: &AckFrame);
    method get_pto (line 72) | fn get_pto(&self, epoch: Epoch) -> Duration;
    method discard_epoch (line 75) | fn discard_epoch(&self, epoch: Epoch);
    method grant_anti_amplification (line 78) | fn grant_anti_amplification(&self);
  type Feedback (line 82) | pub trait Feedback: Send + Sync {
    method may_loss (line 86) | fn may_loss(&self, trigger: PacketLostTrigger, pns: &mut dyn Iterator<...

FILE: qcongestion/src/pacing.rs
  constant BURST_INTERVAL (line 4) | const BURST_INTERVAL: Duration = Duration::from_millis(10);
  constant MIN_BURST_SIZE (line 5) | const MIN_BURST_SIZE: usize = 10;
  constant MAX_BURST_SIZE (line 6) | const MAX_BURST_SIZE: usize = 1280;
  constant N (line 9) | const N: f64 = 1.25;
  type Pacer (line 11) | pub(super) struct Pacer {
    method new (line 20) | pub(super) fn new(
    method on_sent (line 38) | pub(super) fn on_sent(&mut self, packet_size: usize) {
    method schedule (line 43) | pub(super) fn schedule(
    method calculate_capacity (line 81) | fn calculate_capacity(
  function test_pacer_initialization (line 104) | fn test_pacer_initialization() {
  function test_on_sent (line 134) | fn test_on_sent() {
  function test_schedule_no_rate (line 152) | fn test_schedule_no_rate() {
  function test_schedule_with_rate (line 190) | fn test_schedule_with_rate() {

FILE: qcongestion/src/packets.rs
  type State (line 9) | pub(crate) enum State {
  type SentPacket (line 17) | pub struct SentPacket {
    method new (line 27) | pub(crate) fn new(
  method partial_cmp (line 46) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 52) | fn eq(&self, other: &Self) -> bool {
  method cmp (line 58) | fn cmp(&self, other: &Self) -> Ordering {
  type RcvdRecords (line 67) | pub(crate) struct RcvdRecords {
    method new (line 76) | pub(crate) fn new(epoch: Epoch, max_ack_delay: Duration) -> Self {
    method on_pkt_rcvd (line 86) | pub(crate) fn on_pkt_rcvd(&mut self, pn: u64) {
    method need_ack (line 117) | pub(crate) fn need_ack(&self) -> Option<(u64, Instant)> {
    method on_ack_sent (line 134) | pub(crate) fn on_ack_sent(&mut self, _pn: u64, _largest_acked: u64) {
  type PacketSpace (line 142) | pub(crate) struct PacketSpace {
    method with_epoch (line 157) | pub(crate) fn with_epoch(epoch: Epoch, max_ack_delay: Duration) -> Self {
    method update_largest_acked_packet (line 168) | pub(crate) fn update_largest_acked_packet(&mut self, pn: u64) {
    method on_ack_rcvd (line 172) | pub(crate) fn on_ack_rcvd(
    method no_ack_eliciting_in_flight (line 225) | pub(crate) fn no_ack_eliciting_in_flight(&self) -> bool {
    method detect_lost_packets (line 231) | pub(crate) fn detect_lost_packets(
    method discard (line 295) | pub(crate) fn discard(&mut self, algorithm: &mut Box<dyn Control>) {
  type NewlyAckedPackets (line 151) | pub(crate) struct NewlyAckedPackets {
  function test_packet_space (line 318) | fn test_packet_space() {
  function test_rcvd_records (line 390) | async fn test_rcvd_records() {

FILE: qcongestion/src/rtt.rs
  constant INITIAL_RTT (line 6) | pub const INITIAL_RTT: Duration = Duration::from_millis(33);
  constant MAX_INITIAL_RTT (line 7) | pub const MAX_INITIAL_RTT: Duration = Duration::from_millis(333);
  constant GRANULARITY (line 8) | const GRANULARITY: Duration = Duration::from_millis(1);
  constant TIME_THRESHOLD (line 9) | const TIME_THRESHOLD: f32 = 1.125;
  type Rtt (line 12) | pub struct Rtt {
    method update (line 46) | fn update(
    method loss_delay (line 82) | fn loss_delay(&self) -> Duration {
    method base_pto (line 91) | fn base_pto(&self, pto_count: u32) -> Duration {
    method try_backoff_rtt (line 95) | fn try_backoff_rtt(&mut self) {
  method from (line 22) | fn from(rtt: &Rtt) -> Self {
  method default (line 33) | fn default() -> Self {
  type ArcRtt (line 109) | pub struct ArcRtt(Arc<Mutex<Rtt>>);
    method new (line 113) | pub fn new() -> Self {
    method update (line 117) | pub fn update(&self, latest_rtt: Duration, ack_delay: Duration, is_han...
    method loss_delay (line 124) | pub fn loss_delay(&self) -> Duration {
    method smoothed_rtt (line 128) | pub fn smoothed_rtt(&self) -> Duration {
    method rttvar (line 132) | pub fn rttvar(&self) -> Duration {
    method base_pto (line 136) | pub fn base_pto(&self, pto_count: u32) -> Duration {
    method try_backoff_rtt (line 141) | pub fn try_backoff_rtt(&self) {

FILE: qcongestion/src/status.rs
  type HandshakeStatus (line 7) | pub struct HandshakeStatus {
    method new (line 15) | pub fn new(is_server: bool) -> Self {
    method got_handshake_key (line 26) | pub fn got_handshake_key(&self) {
    method received_handshake_ack (line 30) | pub fn received_handshake_ack(&self) {
    method handshake_confirmed (line 35) | pub fn handshake_confirmed(&self) {
  type PathStatus (line 41) | pub struct PathStatus {
    method new (line 48) | pub fn new(handshake: Arc<HandshakeStatus>, pmut: Arc<AtomicU16>) -> S...
    method is_server (line 56) | pub(crate) fn is_server(&self) -> bool {
    method has_handshake_key (line 60) | pub(crate) fn has_handshake_key(&self) -> bool {
    method has_received_handshake_ack (line 64) | pub(crate) fn has_received_handshake_ack(&self) -> bool {
    method is_handshake_confirmed (line 70) | pub(crate) fn is_handshake_confirmed(&self) -> bool {
    method is_at_anti_amplification_limit (line 76) | pub(crate) fn is_at_anti_amplification_limit(&self) -> bool {
    method release_anti_amplification_limit (line 80) | pub fn release_anti_amplification_limit(&self) {
    method enter_anti_amplification_limit (line 85) | pub fn enter_anti_amplification_limit(&self) {
    method pmtu (line 90) | pub(super) fn pmtu(&self) -> Arc<AtomicU16> {
    method mtu (line 94) | pub(crate) fn mtu(&self) -> usize {

FILE: qconnection/src/builder.rs
  method new_client (line 65) | pub fn new_client(server_name: String, token_sink: Arc<dyn TokenSink>) -...
  method new_server (line 73) | pub fn new_server(token_provider: Arc<dyn TokenProvider>) -> ServerFound...
  type ClientFoundation (line 82) | pub struct ClientFoundation {
    method with_parameters (line 89) | pub fn with_parameters(mut self, params: ClientParameters) -> Self {
    method with_tls_config (line 130) | pub fn with_tls_config(
  type ServerFoundation (line 95) | pub struct ServerFoundation {
    method with_parameters (line 102) | pub fn with_parameters(mut self, params: ServerParameters) -> Self {
    method with_client_auther (line 107) | pub fn with_client_auther(mut self, authers: Box<dyn AuthClient>) -> S...
    method with_tls_config (line 173) | pub fn with_tls_config(
  type ConnectionFoundation (line 113) | pub struct ConnectionFoundation<Foundation, TlsConfig> {
  type ClientConnectionFoundation (line 126) | pub type ClientConnectionFoundation = ConnectionFoundation<ClientFoundat...
  type ServerConnectionFoundation (line 127) | pub type ServerConnectionFoundation = ConnectionFoundation<ServerFoundat...
  function with_streams_concurrency_strategy (line 149) | pub fn with_streams_concurrency_strategy<F>(self, strategy_factory: &F) ...
  function with_zero_rtt (line 166) | pub fn with_zero_rtt(mut self, enabled: bool) -> Self {
  function with_streams_concurrency_strategy (line 192) | pub fn with_streams_concurrency_strategy<F>(self, strategy_factory: &F) ...
  function with_zero_rtt (line 209) | pub fn with_zero_rtt(mut self, enabled: bool) -> Self {
  function with_iface_factory (line 219) | pub fn with_iface_factory(mut self, factory: Arc<dyn ProductIO>) -> Self {
  function with_iface_manager (line 224) | pub fn with_iface_manager(mut self, ifaces: Arc<InterfaceManager>) -> Se...
  function with_quic_router (line 229) | pub fn with_quic_router(mut self, quic_router: Arc<QuicRouter>) -> Self {
  function with_locations (line 234) | pub fn with_locations(mut self, locations: Arc<Locations>) -> Self {
  function with_stun_servers (line 239) | pub fn with_stun_servers(mut self, stun_servers: Arc<[SocketAddr]>) -> S...
  function with_defer_idle_timeout (line 244) | pub fn with_defer_idle_timeout(mut self, timeout: Duration) -> Self {
  function initial_keys_with (line 250) | fn initial_keys_with(
  function with_cids (line 271) | pub fn with_cids(self, origin_dcid: ConnectionId) -> PendingConnection {
  function with_cids (line 343) | pub fn with_cids(self, origin_dcid: ConnectionId) -> PendingConnection {
  type PendingConnection (line 404) | pub struct PendingConnection {
    method with_qlog (line 467) | pub fn with_qlog(mut self, qlogger: Arc<dyn QLog>) -> Self {
    method run (line 472) | pub fn run(self) -> Connection {
  function init_stream_and_datagram (line 429) | fn init_stream_and_datagram<LR: IntoRole, RR: IntoRole>(
  function spawn_tls_handshake (line 590) | fn spawn_tls_handshake(components: &Components, tx_wakers: ArcSendWakers) {
  function tls_fin_handler (line 622) | fn tls_fin_handler(
  function spawn_drive_connection (line 736) | fn spawn_drive_connection(mut events: mpsc::UnboundedReceiver<Event>, st...

FILE: qconnection/src/events.rs
  type Event (line 15) | pub enum Event {
  type EmitEvent (line 30) | pub trait EmitEvent: Send + Sync {
    method emit (line 31) | fn emit(&self, event: Event);
    method emit (line 50) | fn emit(&self, event: Event) {
    method emit (line 84) | fn emit(&self, event: Event) {
  type ArcEventBroker (line 35) | pub struct ArcEventBroker {
    method new (line 41) | pub fn new<E: EmitEvent + 'static>(conn_state: ArcConnState, event_bro...
  function test_emit_event (line 96) | fn test_emit_event() {

FILE: qconnection/src/handshake.rs
  type RawHandshake (line 18) | pub type RawHandshake<T> = qbase::handshake::Handshake<T>;
  type Handshake (line 24) | pub struct Handshake<T>
  function new (line 37) | pub fn new(
  function discard_spaces_on_server_handshake_done (line 49) | pub fn discard_spaces_on_server_handshake_done(&self, paths: &ArcPathCon...
  function role (line 59) | pub fn role(&self) -> Role {
  function status (line 63) | pub fn status(&self) -> Arc<HandshakeStatus> {
  function discard_spaces_on_client_handshake_done (line 67) | pub fn discard_spaces_on_client_handshake_done(
  type HandshakeDoneReceiver (line 78) | pub struct HandshakeDoneReceiver<T>
  type Output (line 90) | type Output = ();
  function recv_frame (line 92) | fn recv_frame(&self, frame: HandshakeDoneFrame) -> Result<(), Error> {
  type Target (line 106) | type Target = HandshakeStatus;
  method deref (line 108) | fn deref(&self) -> &Self::Target {

FILE: qconnection/src/lib.rs
  type GuaranteedFrame (line 115) | pub enum GuaranteedFrame {
    type Error (line 122) | type Error = &'f Frame<D>;
    method try_from (line 124) | fn try_from(frame: &'f Frame<D>) -> Result<Self, Self::Error> {
  type InitialJournal (line 135) | pub type InitialJournal = journal::Journal<CryptoFrame>;
  type HandshakeJournal (line 137) | pub type HandshakeJournal = journal::Journal<CryptoFrame>;
  type DataJournal (line 139) | pub type DataJournal = journal::Journal<GuaranteedFrame>;
  type ArcReliableFrameDeque (line 141) | pub type ArcReliableFrameDeque = reliable::ArcReliableFrameDeque<Reliabl...
  type QuicRouterRegistry (line 142) | pub type QuicRouterRegistry = route::QuicRouterRegistry<ArcReliableFrame...
  type ArcLocalCids (line 143) | pub type ArcLocalCids = cid::ArcLocalCids<QuicRouterRegistry>;
  type ArcRemoteCids (line 144) | pub type ArcRemoteCids = cid::ArcRemoteCids<ArcReliableFrameDeque>;
  type CidRegistry (line 145) | pub type CidRegistry = cid::Registry<ArcLocalCids, ArcRemoteCids>;
  type ArcDcidCell (line 146) | pub type ArcDcidCell = cid::ArcCidCell<ArcReliableFrameDeque>;
  type FlowController (line 148) | pub type FlowController = flow::FlowController<ArcReliableFrameDeque>;
  type Credit (line 149) | pub type Credit<'a> = flow::Credit<'a, ArcReliableFrameDeque>;
  type Handshake (line 151) | pub type Handshake = handshake::Handshake<ArcReliableFrameDeque>;
  type RawHandshake (line 152) | pub type RawHandshake = handshake::RawHandshake<ArcReliableFrameDeque>;
  type DataStreams (line 154) | pub type DataStreams = streams::DataStreams<ArcReliableFrameDeque>;
  type StreamReader (line 155) | pub type StreamReader = recv::Reader<Ext<ArcReliableFrameDeque>>;
  type StreamWriter (line 156) | pub type StreamWriter = send::Writer<Ext<ArcReliableFrameDeque>>;
  type ArcPuncher (line 157) | pub type ArcPuncher =
  type Components (line 161) | pub struct Components {
    method role (line 204) | pub fn role(&self) -> Role {
    method metrics (line 212) | pub fn metrics(&self) -> &qbase::metric::ArcConnectionMetrics {
    method open_bi_stream (line 217) | pub fn open_bi_stream(
    method open_uni_stream (line 234) | pub fn open_uni_stream(&self) -> Impl_Future![Result<Option<(StreamId,...
    method accept_bi_stream (line 250) | pub fn accept_bi_stream(
    method accept_uni_stream (line 260) | pub fn accept_uni_stream(&self) -> Impl_Future![Result<(StreamId, Stre...
    method datagram_reader (line 269) | pub fn datagram_reader(&self) -> io::Result<DatagramReader> {
    method datagram_writer (line 275) | pub fn datagram_writer(&self) -> Impl_Future![io::Result<DatagramWrite...
    method add_path (line 290) | pub fn add_path(
    method del_path (line 300) | pub fn del_path(&self, pathway: &Pathway) {
    method local_agent (line 304) | pub fn local_agent(&self) -> Impl_Future![Result<Option<LocalAgent>, E...
    method remote_agent (line 316) | pub fn remote_agent(&self) -> Impl_Future![Result<Option<RemoteAgent>,...
    method enter_closing (line 332) | pub fn enter_closing(self, error: Error) -> Termination {
    method enter_draining (line 376) | pub fn enter_draining(self, ccf: ConnectionCloseFrame) -> Termination {
  type SpecificComponents (line 188) | pub enum SpecificComponents {
  type ConnectionState (line 423) | struct ConnectionState {
    method enter_closing (line 431) | pub fn enter_closing(&self, error: QuicError) -> Result<(), Error> {
    method application_close (line 440) | pub fn application_close(
    method enter_draining (line 458) | pub fn enter_draining(&self, ccf: ConnectionCloseFrame) -> bool {
    method try_map_components (line 470) | fn try_map_components<T>(&self, op: impl FnOnce(&Components) -> T) -> ...
    method try_map_components_future (line 480) | fn try_map_components_future<F, M>(
    method validate (line 494) | fn validate(&self) -> Result<(), Error> {
  method drop (line 518) | fn drop(&mut self) {
  type Connection (line 530) | pub struct Connection(Arc<ConnectionState>);
    method role (line 533) | pub fn role(&self) -> Result<Role, Error> {
    method close (line 540) | pub fn close(&self, reason: impl Into<Cow<'static, str>>, code: u64) -...
    method metrics (line 550) | pub fn metrics(&self) -> Result<qbase::metric::ArcConnectionMetrics, E...
    method open_bi_stream (line 556) | pub fn open_bi_stream(
    method open_uni_stream (line 564) | pub fn open_uni_stream(&self) -> Impl_Future![Result<Option<(StreamId,...
    method accept_bi_stream (line 571) | pub fn accept_bi_stream(
    method accept_uni_stream (line 579) | pub fn accept_uni_stream(&self) -> Impl_Future![Result<(StreamId, Stre...
    method datagram_reader (line 588) | pub fn datagram_reader(&self) -> Result<io::Result<DatagramReader>, Er...
    method datagram_writer (line 596) | pub async fn datagram_writer(&self) -> Result<io::Result<DatagramWrite...
    method add_path (line 603) | pub fn add_path(
    method del_path (line 614) | pub fn del_path(&self, pathway: &Pathway) -> Result<(), Error> {
    method origin_dcid (line 619) | pub fn origin_dcid(&self) -> Result<cid::ConnectionId, Error> {
    method handshaked (line 624) | pub fn handshaked(&self) -> Impl_Future![Result<(), Error>] {
    method terminated (line 630) | pub fn terminated(&self) -> Impl_Future![Error] {
    method local_agent (line 636) | pub fn local_agent(&self) -> Impl_Future![Result<Option<LocalAgent>, E...
    method remote_agent (line 642) | pub fn remote_agent(&self) -> Impl_Future![Result<Option<RemoteAgent>,...
    method server_name (line 648) | pub fn server_name(&self) -> Impl_Future![Result<String, Error>] {
    method add_local_endpoint (line 663) | pub fn add_local_endpoint(&self, bind: BindUri, addr: EndpointAddr) ->...
    method add_peer_endpoint (line 668) | pub fn add_peer_endpoint(
    method remove_address (line 677) | pub fn remove_address(&self, addr: SocketAddr) -> Result<(), Error> {
    method subscribe_local_address (line 682) | pub fn subscribe_local_address(&self) -> Result<(), Error> {
    method path_context (line 687) | pub fn path_context(&self) -> Result<ArcPathContexts, Error> {
    method validate (line 695) | pub fn validate(&self) -> Result<(), Error> {

FILE: qconnection/src/path.rs
  type Path (line 48) | pub struct Path {
    method new (line 193) | pub fn new(
    method cc (line 234) | pub fn cc(&self) -> &ArcCC {
    method on_packet_rcvd (line 238) | pub fn on_packet_rcvd(
    method grant_anti_amplification (line 254) | pub fn grant_anti_amplification(&self) {
    method mtu (line 259) | pub fn mtu(&self) -> u16 {
    method send_packets (line 263) | pub async fn send_packets(&self, bufs: &[io::IoSlice<'_>]) -> io::Resu...
    method deactivate (line 274) | pub fn deactivate(&self) {
    method active (line 278) | pub fn active(&self) {
    method link (line 282) | pub fn link(&self) -> &Link {
    method pathway (line 286) | pub fn pathway(&self) -> &Pathway {
    method bind_uri (line 290) | pub fn bind_uri(&self) -> BindUri {
    type Output (line 302) | type Output = ();
    method recv_frame (line 304) | fn recv_frame(&self, frame: PathChallengeFrame) -> Result<Self::Output...
    type Output (line 311) | type Output = ();
    method recv_frame (line 313) | fn recv_frame(&self, frame: PathResponseFrame) -> Result<Self::Output,...
  method get_or_try_create_path (line 68) | pub fn get_or_try_create_path(
  method drop (line 296) | fn drop(&mut self) {

FILE: qconnection/src/path/aa.rs
  constant DEFAULT_ANTI_FACTOR (line 5) | pub const DEFAULT_ANTI_FACTOR: usize = 3;
  type AntiAmplifier (line 10) | pub struct AntiAmplifier<const N: usize = DEFAULT_ANTI_FACTOR> {
  constant NORMAL (line 21) | const NORMAL: u8 = 0;
  constant GRANTED (line 22) | const GRANTED: u8 = 1;
  constant ABORTED (line 23) | const ABORTED: u8 = 2;
  function new (line 25) | pub fn new(tx_waker: ArcSendWaker) -> Self {
  function on_rcvd (line 34) | pub fn on_rcvd(&self, amount: usize) {
  function balance (line 44) | pub fn balance(&self) -> Result<Option<usize>, Signals> {
  function on_sent (line 71) | pub fn on_sent(&self, amount: usize) {
  function grant (line 77) | pub fn grant(&self) {
  function abort (line 92) | pub fn abort(&self) {
  function test_deposit_and_poll_apply (line 112) | fn test_deposit_and_poll_apply() {
  function test_multiple_deposits (line 133) | fn test_multiple_deposits() {

FILE: qconnection/src/path/burst.rs
  type PacketSpace (line 51) | pub trait PacketSpace<H> {
    method new_packet (line 54) | fn new_packet<'b, 's>(
  type Burst (line 62) | pub struct Burst {
    method assembler (line 296) | fn assembler<'a>(&'a self) -> Result<PacketsAssembler<'a>, BurstError> {
    method load_spaces (line 308) | fn load_spaces(
    method load_ping (line 450) | fn load_ping(&self, buffer: &mut [u8]) -> Result<(usize, PacketContent...
    method load_heartbeat (line 500) | fn load_heartbeat(&self, buffer: &mut [u8]) -> Result<(usize, PacketCo...
    method burst (line 515) | pub async fn burst<'b>(
  function new_burst (line 74) | pub fn new_burst(self: &Arc<Self>, components: &Components) -> Burst {
  type BurstError (line 93) | pub enum BurstError {
  type PacketsAssembler (line 98) | pub struct PacketsAssembler<'a> {
  function new (line 108) | fn new(
  function initial_scid (line 137) | fn initial_scid(&self) -> Result<ConnectionId, Signals> {
  function applied_dcid (line 144) | fn applied_dcid(&self) -> Result<ConnectionId, Signals> {
  function initial_dcid (line 162) | fn initial_dcid(&self) -> Result<ConnectionId, Signals> {
  function commit (line 169) | pub fn commit(&mut self, sent_bytes: usize, pkt_info: PacketInfo) {
  function new_header (line 183) | fn new_header(&self) -> Result<InitialHeader, Signals> {
  function new_header (line 192) | fn new_header(&self) -> Result<ZeroRttHeader, Signals> {
  function new_header (line 198) | fn new_header(&self) -> Result<HandshakeHeader, Signals> {
  function new_header (line 204) | fn new_header(&self) -> Result<OneRttHeader, Signals> {
  function assemble (line 210) | pub fn assemble<'s, 'b, H, Space, P>(
  type PackageIntoSpace (line 232) | pub type PackageIntoSpace<H, S> =
  type DataSources (line 235) | pub struct DataSources {
  method packages (line 243) | pub(super) fn packages(&self) -> DataSources {
  function ack_package (line 282) | fn ack_package<'s, S, F>(space: &'s S, cc: &ArcCC) -> AckPackege<'s>
  type PingSource (line 425) | struct PingSource {
    method dump (line 433) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signa...
  function ping_package (line 442) | fn ping_package(cc: &ArcCC, epoch: Epoch) -> PingSource {

FILE: qconnection/src/path/drive.rs
  function drive (line 7) | pub async fn drive(&self, _tls_handshake: ArcTlsHandshake) -> Result<(),...

FILE: qconnection/src/path/error.rs
  type CreatePathFailure (line 10) | pub enum CreatePathFailure {
  type PathDeactivated (line 18) | pub enum PathDeactivated {

FILE: qconnection/src/path/paths.rs
  type PathContext (line 28) | pub struct PathContext {
  type ArcPathContexts (line 35) | pub struct ArcPathContexts {
    method new (line 43) | pub fn new(tx_wakers: ArcSendWakers, broker: ArcEventBroker) -> Self {
    method assign_handshake_path (line 52) | pub fn assign_handshake_path(
    method handshake_path (line 67) | pub fn handshake_path(&self) -> Option<Arc<Path>> {
    method get_or_try_create_with (line 76) | pub fn get_or_try_create_with<T>(
    method get (line 105) | pub fn get(&self, pathway: &Pathway) -> Option<Arc<Path>> {
    method remove (line 109) | pub fn remove(&self, pathway: &Pathway, reason: &PathDeactivated) {
    method is_empty (line 123) | pub fn is_empty(&self) -> bool {
    method max_pto_duration (line 127) | pub fn max_pto_duration(&self) -> Option<Duration> {
    method paths (line 131) | pub fn paths<C: FromIterator<(Pathway, Arc<Path>)>>(&self) -> C {
    method discard_initial_and_handshake_space (line 138) | pub fn discard_initial_and_handshake_space(&self) {
    method clear (line 145) | pub fn clear(&self) {
    method on_path_validated (line 149) | pub fn on_path_validated(&self, pathway: Pathway) {

FILE: qconnection/src/path/util.rs
  type SendBuffer (line 18) | pub struct SendBuffer<T> {
  function new (line 24) | pub fn new(tx_waker: ArcSendWaker) -> Self {
  function write (line 35) | pub fn write(&self, frame: T) {
  function try_load_frames_into (line 43) | pub fn try_load_frames_into<P: ?Sized>(&self, packet: &mut P) -> Result<...
  function dump (line 64) | fn dump(&mut self, into: &mut P) -> Result<PacketContent, Signals> {
  type RecvBuffer (line 99) | pub struct RecvBuffer<T>(ArcAsyncDeque<T>);
  function new (line 103) | pub fn new() -> Self {
  function write (line 108) | pub fn write(&self, value: T) {
  function receive (line 113) | pub async fn receive(&self) -> Option<T> {
  function dismiss (line 121) | pub fn dismiss(&self) {
  type Item (line 127) | type Item = T;
  function poll_next (line 129) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Item (line 135) | type Item = T;
  function poll_next (line 137) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type Constraints (line 144) | pub struct Constraints {
    method new (line 162) | pub fn new(credit_limit: usize, send_quota: usize) -> Self {
    method is_available (line 178) | pub fn is_available(&self) -> bool {
    method constrain (line 183) | pub fn constrain<'b>(&self, buf: &'b mut [u8]) -> &'b mut [u8] {
    method available (line 191) | pub fn available(&self) -> usize {
    method commit (line 203) | pub fn commit(&mut self, len: usize, in_flight: bool) {
  type ApplyConstraints (line 212) | pub trait ApplyConstraints {
    method apply (line 214) | fn apply(self, constraints: &Constraints) -> Self;
    method apply (line 218) | fn apply(self, constraints: &Constraints) -> Self {

FILE: qconnection/src/path/validate.rs
  type ValidateFailure (line 9) | pub enum ValidateFailure {
  function validated (line 19) | pub fn validated(&self) {
  function validate (line 24) | pub async fn validate(&self) -> Result<(), ValidateFailure> {

FILE: qconnection/src/space.rs
  type Spaces (line 42) | pub struct Spaces {
    method new (line 49) | pub fn new(
    method initial (line 61) | pub fn initial(&self) -> &Arc<initial::InitialSpace> {
    method handshake (line 65) | pub fn handshake(&self) -> &Arc<handshake::HandshakeSpace> {
    method data (line 69) | pub fn data(&self) -> &Arc<data::DataSpace> {
    method send_ccf_packets (line 103) | pub async fn send_ccf_packets(&self, t: &Terminator) {
  function assemble_closing_packet (line 74) | fn assemble_closing_packet<'s, 'b: 's, H, S>(
  function pipe (line 125) | fn pipe<F: Send + Debug + 'static>(
  type FlowControlledDataStreams (line 147) | struct FlowControlledDataStreams {
    method new (line 153) | fn new(streams: DataStreams, flow_ctrl: FlowController) -> Self {
    type Output (line 159) | type Output = ();
    method recv_frame (line 161) | fn recv_frame(&self, data_frame: (StreamFrame, Bytes)) -> Result<Self:...
    type Output (line 170) | type Output = ();
    method recv_frame (line 172) | fn recv_frame(&self, frame: StreamCtlFrame) -> Result<Self::Output, Er...
  type AckInitialSpace (line 180) | struct AckInitialSpace {
    method new (line 186) | fn new(journal: &Journal<CryptoFrame>, crypto_stream: &CryptoStream) -...
    type Output (line 195) | type Output = ();
    method recv_frame (line 197) | fn recv_frame(&self, ack_frame: AckFrame) -> Result<Self::Output, Erro...
  type AckHandshakeSpace (line 216) | struct AckHandshakeSpace {
    method new (line 222) | fn new(journal: &Journal<CryptoFrame>, crypto_stream: &CryptoStream) -...
    type Output (line 231) | type Output = ();
    method recv_frame (line 233) | fn recv_frame(&self, ack_frame: AckFrame) -> Result<Self::Output, Erro...
  type AckDataSpace (line 252) | struct AckDataSpace {
    method new (line 259) | fn new(
    type Output (line 273) | type Output = ();
    method recv_frame (line 275) | fn recv_frame(&self, ack_frame: AckFrame) -> Result<Self::Output, Erro...
  function spawn_deliver_and_parse (line 304) | pub fn spawn_deliver_and_parse(components: &Components) {
  function filter_odcid_packet (line 339) | fn filter_odcid_packet<H: GetDcid>(
  function read_plain_packet (line 362) | fn read_plain_packet<H>(

FILE: qconnection/src/space/data.rs
  type CipherZeroRttPacket (line 51) | pub type CipherZeroRttPacket = CipherPacket<ZeroRttHeader>;
  type PlainZeroRttPacket (line 52) | pub type PlainZeroRttPacket = PlainPacket<ZeroRttHeader>;
  type ReceivedZeroRttFrom (line 53) | pub type ReceivedZeroRttFrom = (CipherZeroRttPacket, (BindUri, Pathway, ...
  type CipherOneRttPacket (line 55) | pub type CipherOneRttPacket = CipherPacket<OneRttHeader>;
  type PlainOneRttPacket (line 56) | pub type PlainOneRttPacket = PlainPacket<OneRttHeader>;
  type ReceivedOneRttFrom (line 57) | pub type ReceivedOneRttFrom = (CipherOneRttPacket, (BindUri, Pathway, Li...
  type DataSpace (line 59) | pub struct DataSpace {
    method as_ref (line 66) | fn as_ref(&self) -> &DataJournal {
    method new (line 72) | pub fn new(zero_rtt_keys: ArcZeroRttKeys) -> Self {
    method decrypt_0rtt_packet (line 80) | pub async fn decrypt_0rtt_packet(
    method decrypt_1rtt_packet (line 98) | pub async fn decrypt_1rtt_packet(
    method is_one_rtt_keys_ready (line 113) | pub fn is_one_rtt_keys_ready(&self) -> bool {
    method is_zero_rtt_avaliable (line 117) | pub fn is_zero_rtt_avaliable(&self) -> bool {
    method one_rtt_keys (line 121) | pub fn one_rtt_keys(&self) -> ArcOneRttKeys {
    method zero_rtt_keys (line 125) | pub fn zero_rtt_keys(&self) -> ArcZeroRttKeys {
    method journal (line 129) | pub(crate) fn journal(&self) -> &DataJournal {
    method tracker (line 133) | pub fn tracker(
    type JournalFrame (line 155) | type JournalFrame = GuaranteedFrame;
    method new_packet (line 157) | fn new_packet<'b, 's>(
    type PacketAssembler (line 184) | type PacketAssembler<'a> = TrivialPacketWriter<'a, 'a, GuaranteedFrame>;
    method new_packet (line 187) | fn new_packet<'a>(
    type JournalFrame (line 205) | type JournalFrame = GuaranteedFrame;
    method new_packet (line 207) | fn new_packet<'b, 's>(
    type PacketAssembler (line 232) | type PacketAssembler<'a> = TrivialPacketWriter<'a, 'a, GuaranteedFrame>;
    method new_packet (line 235) | fn new_packet<'a>(
  method epoch (line 149) | fn epoch(&self) -> Epoch {
  function frame_dispathcer (line 255) | fn frame_dispathcer(
  function parse_normal_zero_rtt_packet (line 420) | async fn parse_normal_zero_rtt_packet(
  function parse_normal_one_rtt_packet (line 460) | async fn parse_normal_one_rtt_packet(
  function parse_closing_one_rtt_packet (line 503) | fn parse_closing_one_rtt_packet(
  function deliver_and_parse_packets (line 524) | pub async fn deliver_and_parse_packets(
  type DataTracker (line 599) | pub struct DataTracker {
  method may_loss (line 607) | fn may_loss(&self, trigger: PacketLostTrigger, pns: &mut dyn Iterator<It...

FILE: qconnection/src/space/handshake.rs
  type CipherHanshakePacket (line 35) | pub type CipherHanshakePacket = CipherPacket<HandshakeHeader>;
  type PlainHandshakePacket (line 36) | pub type PlainHandshakePacket = PlainPacket<HandshakeHeader>;
  type ReceivedFrom (line 37) | pub type ReceivedFrom = (CipherHanshakePacket, Way);
  type HandshakeSpace (line 39) | pub struct HandshakeSpace {
    method as_ref (line 45) | fn as_ref(&self) -> &HandshakeJournal {
    method new (line 51) | pub fn new() -> Self {
    method keys (line 58) | pub fn keys(&self) -> ArcKeys {
    method decrypt_packet (line 62) | pub async fn decrypt_packet(
    method tracker (line 79) | pub fn tracker(&self, crypto_stream: CryptoStream) -> HandshakeTracker {
    type JournalFrame (line 100) | type JournalFrame = CryptoFrame;
    method new_packet (line 102) | fn new_packet<'b, 's>(
    type PacketAssembler (line 122) | type PacketAssembler<'a> = TrivialPacketWriter<'a, 'a, CryptoFrame>;
    method new_packet (line 125) | fn new_packet<'a>(
  method default (line 88) | fn default() -> Self {
  method epoch (line 94) | fn epoch(&self) -> Epoch {
  function frame_dispathcer (line 135) | fn frame_dispathcer(
  function parse_normal_packet (line 171) | async fn parse_normal_packet(
  function parse_closing_packet (line 215) | fn parse_closing_packet(
  function deliver_and_parse_packets (line 239) | pub async fn deliver_and_parse_packets(
  type HandshakeTracker (line 288) | pub struct HandshakeTracker {
  method may_loss (line 294) | fn may_loss(&self, trigger: PacketLostTrigger, pns: &mut dyn Iterator<It...

FILE: qconnection/src/space/initial.rs
  type CipherInitialPacket (line 40) | pub type CipherInitialPacket = CipherPacket<InitialHeader>;
  type PlainInitialPacket (line 41) | pub type PlainInitialPacket = PlainPacket<InitialHeader>;
  type ReceivedFrom (line 42) | pub type ReceivedFrom = (CipherInitialPacket, Way);
  type InitialSpace (line 44) | pub struct InitialSpace {
    method as_ref (line 50) | fn as_ref(&self) -> &InitialJournal {
    method new (line 57) | pub fn new(keys: Keys) -> Self {
    method keys (line 65) | pub fn keys(&self) -> ArcKeys {
    method decrypt_packet (line 69) | pub async fn decrypt_packet(
    method tracker (line 86) | pub fn tracker(&self, crypto_stream: CryptoStream) -> InitialTracker {
    type JournalFrame (line 101) | type JournalFrame = CryptoFrame;
    method new_packet (line 103) | fn new_packet<'b, 's>(
    type PacketAssembler (line 123) | type PacketAssembler<'a> = TrivialPacketWriter<'a, 'a, CryptoFrame>;
    method new_packet (line 126) | fn new_packet<'a>(
  method epoch (line 95) | fn epoch(&self) -> Epoch {
  function frame_dispathcer (line 136) | fn frame_dispathcer(
  function parse_normal_packet (line 170) | async fn parse_normal_packet(
  function parse_closing_packet (line 250) | fn parse_closing_packet(
  function deliver_and_parse_packets (line 274) | pub async fn deliver_and_parse_packets(
  type InitialTracker (line 324) | pub struct InitialTracker {
  method may_loss (line 330) | fn may_loss(&self, trigger: PacketLostTrigger, pns: &mut dyn Iterator<It...

FILE: qconnection/src/state.rs
  type ArcConnState (line 27) | pub struct ArcConnState {
    method new (line 44) | pub fn new() -> Self {
    method try_entry_attempted (line 53) | pub fn try_entry_attempted(&self, components: &Components, link: Link)...
    method update (line 98) | pub fn update(&self, state: QlogConnectionState) -> Option<QlogConnect...
    method enter_handshaked (line 127) | pub fn enter_handshaked(&self) -> Option<QlogConnectionState> {
    method enter_closing (line 135) | pub fn enter_closing(&self, error: &(impl Into<Error> + Clone)) -> Opt...
    method enter_draining (line 145) | pub fn enter_draining(&self, ccf: &ConnectionCloseFrame) -> Option<Qlo...
    method handshaked (line 157) | pub fn handshaked(&self) -> impl Future<Output = Result<(), Error>> + ...
    method terminated (line 170) | pub fn terminated(&self) -> impl Future<Output = Error> + Send + use<> {
    method current (line 177) | pub fn current(&self) -> Option<QlogConnectionState> {
  method default (line 34) | fn default() -> Self {
  constant HANDSHAKE_CONFIRMED (line 213) | pub const HANDSHAKE_CONFIRMED: QlogConnectionState =
  constant CLOSING (line 216) | pub const CLOSING: QlogConnectionState =
  constant DRAINING (line 219) | pub const DRAINING: QlogConnectionState =
  constant CLOSED (line 222) | pub const CLOSED: QlogConnectionState =

FILE: qconnection/src/termination.rs
  type Terminator (line 31) | pub struct Terminator {
    method new_header (line 47) | fn new_header(&self) -> Result<InitialHeader, Signals> {
    method new_header (line 57) | fn new_header(&self) -> Result<HandshakeHeader, Signals> {
    method new_header (line 66) | fn new_header(&self) -> Result<OneRttHeader, Signals> {
    method new (line 76) | pub fn new(ccf: ConnectionCloseFrame, components: &Components) -> Self {
    method should_send (line 87) | pub fn should_send(&self) -> bool {
    method try_send (line 102) | pub async fn try_send<W>(&self, mut write: W)
    method try_send_on (line 118) | pub async fn try_send_on<W>(&self, pathway: Pathway, write: W)
  method drop (line 41) | fn drop(&mut self) {
  type State (line 139) | enum State {
  type Termination (line 145) | pub struct Termination {
    method closing (line 154) | pub fn closing(error: Error, local_cids: ArcLocalCids, state: Arc<Rcvd...
    method draining (line 162) | pub fn draining(error: Error, local_cids: ArcLocalCids) -> Self {
    method error (line 170) | pub fn error(&self) -> Error {
    method enter_draining (line 175) | pub fn enter_draining(&mut self) -> bool {

FILE: qconnection/src/tls.rs
  type TlsSession (line 33) | pub enum TlsSession {
    method poll_read_hs (line 41) | fn poll_read_hs(&mut self, cx: &mut Context, buf: &mut Vec<u8>) -> Pol...
    method write_hs (line 57) | fn write_hs(&mut self, buf: &[u8]) -> Result<(), rustls::Error> {
    method alert (line 71) | fn alert(&self) -> Option<rustls::AlertDescription> {
    method is_handshaking (line 78) | fn is_handshaking(&self) -> bool {
    method handshake_kind (line 85) | fn handshake_kind(&self) -> Option<HandshakeKind> {
    method is_finished (line 92) | fn is_finished(&self) -> bool {
    method r#yield (line 96) | fn r#yield(&self) -> TlsHandshakeInfo {
  constant QUIC_VERSION (line 38) | pub const QUIC_VERSION: rustls::quic::Version = rustls::quic::Version::V1;
  type ClientTlsSession (line 112) | pub struct ClientTlsSession {
    method init (line 158) | pub fn init(
    method local_agent (line 192) | fn local_agent(&self) -> MutexGuard<'_, Option<LocalAgent>> {
    method load_zero_rtt (line 197) | pub fn load_zero_rtt(&self) -> Option<(ServerParameters, DirectionalKe...
    method try_process_sh (line 210) | fn try_process_sh(&mut self) {
    method try_process_ee (line 215) | fn try_process_ee(&mut self, parameters: &ArcParameters) -> Result<(),...
  type ClientCertResolver (line 124) | struct ClientCertResolver {
  method resolve (line 131) | fn resolve(
  method only_raw_public_keys (line 148) | fn only_raw_public_keys(&self) -> bool {
  method has_certs (line 152) | fn has_certs(&self) -> bool {
  method drop (line 236) | fn drop(&mut self) {
  type ServerTlsSession (line 243) | pub struct ServerTlsSession {
    method init (line 280) | pub fn init(
    method send_lock (line 311) | pub fn send_lock(&self) -> &ArcSendLock {
    method local_agent (line 315) | fn local_agent(&self) -> MutexGuard<'_, Option<LocalAgent>> {
    method server_name (line 319) | pub fn server_name(&self) -> Option<String> {
    method try_process_ch (line 323) | fn try_process_ch(
    method try_process_cert (line 387) | fn try_process_cert(&mut self) -> Result<(), Error> {
  type ServerCertResolver (line 256) | struct ServerCertResolver {
  method resolve (line 262) | fn resolve(&self, client_hello: ClientHello<'_>) -> Option<Arc<Certified...
  method only_raw_public_keys (line 274) | fn only_raw_public_keys(&self) -> bool {
  method drop (line 427) | fn drop(&mut self) {
  type TlsHandshakeInfo (line 435) | pub enum TlsHandshakeInfo {
    method zero_rtt_accepted (line 448) | pub fn zero_rtt_accepted(&self) -> Option<bool> {
  type InfoState (line 458) | enum InfoState {
    method set (line 464) | fn set(&mut self, info: Arc<TlsHandshakeInfo>) {
    method poll_get (line 469) | fn poll_get(&mut self, cx: &mut Context) -> Poll<Arc<TlsHandshakeInfo>> {
    method get (line 479) | fn get(&self) -> Option<&Arc<TlsHandshakeInfo>> {
  method default (line 488) | fn default() -> Self {
  method drop (line 494) | fn drop(&mut self) {
  type TlsHandshake (line 503) | pub struct TlsHandshake {
  type ArcTlsHandshake (line 509) | pub struct ArcTlsHandshake(Arc<Mutex<Result<TlsHandshake, Error>>>);
    method new (line 512) | pub fn new(session: TlsSession) -> ArcTlsHandshake {
    method state (line 519) | fn state(&self) -> MutexGuard<'_, Result<TlsHandshake, Error>> {
    method read_hs (line 523) | async fn read_hs(&self, buf: &mut Vec<u8>) -> Result<Option<KeyChange>...
    method write_hs (line 534) | fn write_hs(&self, buf: &[u8]) -> Result<(), Error> {
    method info (line 552) | pub fn info(
    method is_finished (line 564) | pub fn is_finished(&self) -> Result<bool, Error> {
    method server_name (line 572) | pub fn server_name(&self) -> Result<Option<String>, Error> {
    method on_conn_error (line 581) | pub fn on_conn_error(&self, error: &Error) {
    method try_process_tls_message (line 585) | fn try_process_tls_message(
    method start (line 622) | pub fn start(

FILE: qconnection/src/tls/agent.rs
  type LocalAgent (line 13) | pub struct LocalAgent {
    method new (line 30) | pub fn new(name: Arc<str>, certified_key: Arc<CertifiedKey>) -> Self {
    method name (line 37) | pub fn name(&self) -> &str {
    method cert_chain (line 41) | pub fn cert_chain(&self) -> &[CertificateDer<'static>] {
    method public_key (line 45) | pub fn public_key(&self) -> SubjectPublicKeyInfoDer<'_> {
    method sign_algorithm (line 49) | pub fn sign_algorithm(&self) -> rustls::SignatureAlgorithm {
    method sign (line 53) | pub fn sign(&self, scheme: SignatureScheme, data: &[u8]) -> Result<Vec...
    method verify (line 57) | pub fn verify(
  type SignError (line 19) | pub enum SignError {
  type RemoteAgent (line 68) | pub struct RemoteAgent {
    method new (line 80) | pub fn new(name: Arc<str>, cert: Arc<[CertificateDer<'static>]>) -> Se...
    method name (line 84) | pub fn name(&self) -> &str {
    method cert_chain (line 88) | pub fn cert_chain(&self) -> &[CertificateDer<'static>] {
    method public_key (line 92) | pub fn public_key(&self) -> SubjectPublicKeyInfoDer<'_> {
    method verify (line 96) | pub fn verify(
  type VerifyError (line 74) | pub enum VerifyError {
  function public_key (line 106) | fn public_key<'d>(cert_chain: &'d [CertificateDer<'d>]) -> SubjectPublic...
  function sign (line 119) | fn sign(
  function verify (line 131) | fn verify(

FILE: qconnection/src/tls/client_auth.rs
  type ClientNameVerifyResult (line 11) | pub enum ClientNameVerifyResult {
  type Output (line 23) | type Output = Self;
  method bitand (line 25) | fn bitand(self, rhs: Self) -> Self::Output {
  type ClientAgentVerifyResult (line 36) | pub enum ClientAgentVerifyResult {
  type Output (line 43) | type Output = Self;
  method bitand (line 45) | fn bitand(self, rhs: Self) -> Self::Output {
  type AuthClient (line 54) | pub trait AuthClient: Send + Sync {
    method verify_client_name (line 55) | fn verify_client_name(
    method verify_client_agent (line 61) | fn verify_client_agent(
    method verify_client_name (line 72) | fn verify_client_name(&self, _: &LocalAgent, _: Option<&str>) -> Clien...
    method verify_client_agent (line 76) | fn verify_client_agent(&self, _: &LocalAgent, _: &RemoteAgent) -> Clie...
    method verify_client_name (line 85) | fn verify_client_name(&self, _: &LocalAgent, _: Option<&str>) -> Clien...
    method verify_client_agent (line 89) | fn verify_client_agent(
    method verify_client_name (line 123) | fn verify_client_name(
    method verify_client_agent (line 131) | fn verify_client_agent(
    method verify_client_name (line 141) | fn verify_client_name(
    method verify_client_agent (line 149) | fn verify_client_agent(
    method verify_client_name (line 159) | fn verify_client_name(
    method verify_client_agent (line 167) | fn verify_client_agent(
  type AcceptAllClientAuther (line 69) | pub struct AcceptAllClientAuther;
  type ClientNameAuther (line 82) | pub struct ClientNameAuther;
  type ArcSendLock (line 225) | pub struct ArcSendLock(Arc<SetOnce<()>>);
    method new (line 234) | pub fn new() -> Self {
    method unrestricted (line 244) | pub fn unrestricted() -> Self {
    method request_permit (line 254) | pub async fn request_permit(&self) {
    method is_permitted (line 259) | pub fn is_permitted(&self) -> bool {
    method grant_permit (line 267) | pub fn grant_permit(&self) {

FILE: qconnection/src/traversal.rs
  type Output (line 22) | type Output = ();
  method recv_frame (line 23) | fn recv_frame(
  type Output (line 32) | type Output = ();
  method recv_frame (line 34) | fn recv_frame(
  method subscribe_local_address (line 43) | pub fn subscribe_local_address(&self) {
  method add_local_endpoint (line 98) | pub fn add_local_endpoint(&self, bind: BindUri, addr: EndpointAddr) {
  method add_peer_endpoint (line 114) | pub fn add_peer_endpoint(&self, addr: EndpointAddr, source: qresolve::So...
  method add_local_punch_address (line 129) | pub fn add_local_punch_address(
  method remove_address (line 176) | pub fn remove_address(&self, addr: SocketAddr) {
  type PunchTransaction (line 182) | pub struct PunchTransaction {
    method new (line 187) | pub(crate) fn new(cid_registry: CidRegistry) -> Self {
    method new_header (line 193) | fn new_header(&self) -> Result<OneRttHeader, Signals> {

FILE: qconnection/src/tx.rs
  type PacketWriter (line 19) | pub struct PacketWriter<'b, 's, F> {
  function as_ref (line 30) | fn as_ref(&self) -> &BasePacketWriter<'b> {
  function as_ref (line 37) | fn as_ref(&self) -> &QEventPacketWriter<'b> {
  function new_long (line 43) | pub fn new_long<S>(
  function new_short (line 66) | pub fn new_short(
  method remaining_mut (line 88) | fn remaining_mut(&self) -> usize {
  method advance_mut (line 93) | unsafe fn advance_mut(&mut self, cnt: usize) {
  method chunk_mut (line 98) | fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
  method put_bytes (line 104) | fn put_bytes(&mut self, val: u8, cnt: usize) {
  method encrypt_and_protect_packet (line 111) | fn encrypt_and_protect_packet(self) -> (usize, PacketInfo) {
  function record_frame (line 124) | fn record_frame(&mut self, frame: &F) {
  type TrivialPacketWriter (line 136) | pub struct TrivialPacketWriter<'b, 's, F> {
  function as_ref (line 145) | fn as_ref(&self) -> &BasePacketWriter<'b> {
  function as_ref (line 152) | fn as_ref(&self) -> &QEventPacketWriter<'b> {
  function new_long (line 159) | pub fn new_long<S>(
  function new_short (line 179) | pub fn new_short(
  method remaining_mut (line 197) | fn remaining_mut(&self) -> usize {
  method advance_mut (line 202) | unsafe fn advance_mut(&mut self, cnt: usize) {
  method chunk_mut (line 207) | fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
  method put_bytes (line 213) | fn put_bytes(&mut self, val: u8, cnt: usize) {
  method encrypt_and_protect_packet (line 220) | fn encrypt_and_protect_packet(self) -> (usize, PacketInfo) {
  function record_frame (line 232) | fn record_frame(&mut self, frame: &F) {

FILE: qdatagram/src/lib.rs
  type DatagramFlow (line 17) | pub struct DatagramFlow {
    method new (line 33) | pub fn new(local_max_datagram_frame_size: u64, tx_wakers: ArcSendWaker...
    method try_load_data_into (line 40) | pub fn try_load_data_into<P>(&self, packet: &mut P) -> Result<(), Sign...
    method reader (line 55) | pub fn reader(&self) -> io::Result<DatagramReader> {
    method writer (line 66) | pub fn writer(&self, max_datagram_frame_size: u64) -> io::Result<Datag...
    method on_conn_error (line 72) | pub fn on_conn_error(&self, error: &Error) {
    type Output (line 80) | type Output = ();
    method recv_frame (line 83) | fn recv_frame(&self, (frame, body): (DatagramFrame, Bytes)) -> Result<...

FILE: qdatagram/src/reader.rs
  type RawDatagarmReader (line 17) | struct RawDatagarmReader {
    method new (line 24) | fn new(local_max_size: usize) -> Self {
  type DatagramIncoming (line 34) | pub struct DatagramIncoming(Arc<Mutex<Result<RawDatagarmReader, Error>>>);
    method new (line 38) | pub fn new(local_max_size: usize) -> Self {
    method new_reader (line 48) | pub fn new_reader(&self) -> io::Result<DatagramReader> {
    method recv_datagram (line 70) | pub fn recv_datagram(&self, frame: DatagramFrame, data: bytes::Bytes) ...
    method on_conn_error (line 103) | pub fn on_conn_error(&self, error: &Error) {
  type DatagramReader (line 118) | pub struct DatagramReader(Arc<Mutex<Result<RawDatagarmReader, Error>>>);
    method poll_recv (line 137) | pub fn poll_recv(&self, cx: &mut Context<'_>) -> Poll<io::Result<Bytes...
    method recv (line 166) | pub fn recv(&mut self) -> RecvDatagram<'_> {
    method read (line 185) | pub fn read<'b>(&'b mut self, buf: &'b mut [u8]) -> ReadIntoSlice<'b> {
    method read_buf (line 204) | pub fn read_buf<'b, B: BufMut>(&'b mut self, buf: &'b mut B) -> ReadIn...
  type RecvDatagram (line 210) | pub struct RecvDatagram<'a> {
  type Output (line 215) | type Output = io::Result<Bytes>;
  method poll (line 217) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type ReadIntoSlice (line 223) | pub struct ReadIntoSlice<'a> {
  type Output (line 229) | type Output = io::Result<usize>;
  method poll (line 231) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type ReadIntoBuf (line 242) | pub struct ReadIntoBuf<'a, B> {
  type Output (line 251) | type Output = io::Result<usize>;
  method poll (line 253) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function test_datagram_reader_recv_buf (line 270) | async fn test_datagram_reader_recv_buf() {
  function test_datagram_reader_on_conn_error (line 292) | async fn test_datagram_reader_on_conn_error() {

FILE: qdatagram/src/writer.rs
  type RawDatagramWriter (line 18) | struct RawDatagramWriter {
    method new (line 25) | fn new(tx_wakers: ArcSendWakers) -> Self {
  type DatagramOutgoing (line 35) | pub struct DatagramOutgoing(Arc<Mutex<Result<RawDatagramWriter, Error>>>);
    method new (line 38) | pub fn new(tx_wakers: ArcSendWakers) -> DatagramOutgoing {
    method new_writer (line 48) | pub fn new_writer(&self, max_datagram_frame_size: u64) -> io::Result<D...
    method try_read_datagram (line 66) | fn try_read_datagram(&self, mut buf: &mut [u8]) -> Option<(DatagramFra...
    method try_load_data_into (line 124) | pub fn try_load_data_into<P>(&self, packet: &mut P) -> Result<(), Sign...
    method on_conn_error (line 166) | pub fn on_conn_error(&self, error: &Error) {
  type DatagramWriter (line 180) | pub struct DatagramWriter {
    method send_bytes (line 209) | pub fn send_bytes(&self, data: Bytes) -> io::Result<()> {
    method send (line 246) | pub fn send(&self, data: &[u8]) -> io::Result<()> {
    method max_datagram_frame_size (line 267) | pub fn max_datagram_frame_size(&self) -> io::Result<usize> {
  function test_datagram_writer_with_length (line 288) | fn test_datagram_writer_with_length() {
  function test_datagram_writer_without_length (line 311) | fn test_datagram_writer_without_length() {
  function test_datagram_writer_unwritten (line 333) | fn test_datagram_writer_unwritten() {
  function test_datagram_writer_padding_first (line 348) | fn test_datagram_writer_padding_first() {
  function test_datagram_writer_exceeds_limit (line 374) | fn test_datagram_writer_exceeds_limit() {
  function test_datagram_writer_on_conn_error (line 380) | fn test_datagram_writer_on_conn_error() {

FILE: qevent/src/legacy.rs
  constant QLOG_VERSION (line 13) | pub const QLOG_VERSION: &str = "0.3";
  type QlogFile (line 18) | pub struct QlogFile {
    method default_format (line 34) | pub fn default_format() -> String {
  type QlogFileSeq (line 42) | pub struct QlogFileSeq {
    method default_qlog_version (line 60) | pub fn default_qlog_version() -> String {
    method default_format (line 64) | pub fn default_format() -> String {
  type Summary (line 72) | pub struct Summary {
  type Traces (line 81) | pub enum Traces {
  type TraceError (line 89) | pub struct TraceError {
  type Trace (line 99) | pub struct Trace {
  type TraceSeq (line 115) | pub struct TraceSeq {
  type Configuration (line 125) | pub struct Configuration {
  type Event (line 137) | pub struct Event {
  type TimeFormat (line 158) | pub enum TimeFormat {
  type EventData (line 167) | pub enum EventData {
  type ProtocolType (line 283) | pub struct ProtocolType(Vec<String>);
  type CommonFields (line 288) | pub struct CommonFields {
  type GenericError (line 301) | pub struct GenericError {
  type GenericWarning (line 309) | pub struct GenericWarning {
  type GenericInfo (line 317) | pub struct GenericInfo {
  type GenericDebug (line 324) | pub struct GenericDebug {
  type GenericVerbose (line 331) | pub struct GenericVerbose {
  type SimulationScenario (line 338) | pub struct SimulationScenario {
  type SimulationMarker (line 348) | pub struct SimulationMarker {

FILE: qevent/src/legacy/exporter.rs
  type IoExpoter (line 11) | pub struct IoExpoter(mpsc::UnboundedSender<Event>);
    method new (line 14) | pub fn new<O>(qlog_file_seq: QlogFileSeq, mut output: O) -> Self
  method emit (line 54) | fn emit(&self, event: Event) {
  function io_exporter (line 71) | async fn io_exporter() {

FILE: qevent/src/legacy/quic.rs
  type ConnectivityServerListening (line 17) | pub struct ConnectivityServerListening {
  type ConnectivityConnectionStarted (line 31) | pub struct ConnectivityConnectionStarted {
    method default_protocol (line 53) | pub fn default_protocol() -> String {
  type ConnectivityConnectionClosed (line 61) | pub struct ConnectivityConnectionClosed {
  type ConnectionCode (line 81) | pub enum ConnectionCode {
  type ApplicationCode (line 89) | pub enum ApplicationCode {
  type ConnectivityConnectionClosedTrigger (line 96) | pub enum ConnectivityConnectionClosedTrigger {
  type ConnectivityConnectionIdUpdated (line 111) | pub struct ConnectivityConnectionIdUpdated {
  type ConnectivitySpinBitUpdated (line 121) | pub struct ConnectivitySpinBitUpdated {
  type ConnectivityConnectionStateUpdated (line 128) | pub struct ConnectivityConnectionStateUpdated {
  type ConnectionState (line 137) | pub enum ConnectionState {
  type SecurityKeyUpdated (line 163) | pub struct SecurityKeyUpdated {
  type SecurityKeyUpdatedTrigger (line 177) | pub enum SecurityKeyUpdatedTrigger {
  type SecurityKeyRetired (line 188) | pub struct SecurityKeyRetired {
  type SecurityKeyRetiredTrigger (line 200) | pub enum SecurityKeyRetiredTrigger {
  type TransportVersionInformation (line 211) | pub struct TransportVersionInformation {
  type TransportALPNInformation (line 222) | pub struct TransportALPNInformation {
  type TransportParametersSet (line 235) | pub struct TransportParametersSet {
    method default_aead_key_length (line 277) | pub fn default_aead_key_length() -> u8 {
  type PreferredAddress (line 285) | pub struct PreferredAddress {
  type TransportParametersRestored (line 299) | pub struct TransportParametersRestored {
  type TransportPacketSent (line 317) | pub struct TransportPacketSent {
  type TransportPacketSentTrigger (line 352) | pub enum TransportPacketSentTrigger {
  type TransportPacketReceived (line 363) | pub struct TransportPacketReceived {
  type TransportPacketReceivedTrigger (line 399) | pub enum TransportPacketReceivedTrigger {
  type TransportPacketDropped (line 410) | pub struct TransportPacketDropped {
  type TransportpacketDroppedTrigger (line 423) | pub enum TransportpacketDroppedTrigger {
  type TransportPacketBuffered (line 445) | pub struct TransportPacketBuffered {
  type TransportPacketBufferedTrigger (line 458) | pub enum TransportPacketBufferedTrigger {
  type TransportPacketsAcked (line 474) | pub struct TransportPacketsAcked {
  type TransportDatagramsSent (line 488) | pub struct TransportDatagramsSent {
  type TransportDatagramsReceived (line 508) | pub struct TransportDatagramsReceived {
  type TransportDatagramDropped (line 528) | pub struct TransportDatagramDropped {
  type TransportStreamStateUpdated (line 535) | pub struct TransportStreamStateUpdated {
  type StreamState (line 552) | pub enum StreamState {
  type StreamType (line 578) | pub enum StreamType {
  type StreamSide (line 585) | pub enum StreamSide {
  type TransportFramesProcessed (line 593) | pub struct TransportFramesProcessed {
  type TransportDataMoved (line 608) | pub struct TransportDataMoved {
  type StreamDataLocation (line 623) | pub enum StreamDataLocation {
    method deserialize (line 647) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 632) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type RecoveryParametersSet (line 664) | pub struct RecoveryParametersSet {
  type RecoveryMetricsUpdated (line 711) | pub struct RecoveryMetricsUpdated {
  type RecoveryCongestionStateUpdated (line 757) | pub struct RecoveryCongestionStateUpdated {
  type RecoveryCongestionStateUpdatedTrigger (line 768) | pub enum RecoveryCongestionStateUpdatedTrigger {
  type RecoveryLossTimerUpdated (line 776) | pub struct RecoveryLossTimerUpdated {
  type LossTimerType (line 793) | pub enum LossTimerType {
  type LossTimerEventType (line 800) | pub enum LossTimerEventType {
  type RecoveryPacketLost (line 813) | pub struct RecoveryPacketLost {
  type RecoveryPacketLostTrigger (line 827) | pub enum RecoveryPacketLostTrigger {
  type RecoveryMarkedForRetransmit (line 837) | pub struct RecoveryMarkedForRetransmit {
  type QuicVersion (line 847) | pub struct QuicVersion(HexString);
  type ConnectionID (line 851) | pub struct ConnectionID(HexString);
  type Owner (line 855) | pub enum Owner {
  type IPAddress (line 863) | pub struct IPAddress(String);
  type IPVersion (line 867) | pub enum IPVersion {
  type PacketType (line 875) | pub enum PacketType {
  type PacketNumberSpace (line 891) | pub enum PacketNumberSpace {
  type PacketHeader (line 902) | pub struct PacketHeader {
  type Token (line 948) | pub struct Token {
  type TokenType (line 966) | pub enum TokenType {
  type KeyType (line 976) | pub enum KeyType {
  type ConnectionCloseTriggerFrameType (line 993) | pub enum ConnectionCloseTriggerFrameType {
  type ConnectionCloseErrorCode (line 1000) | pub enum ConnectionCloseErrorCode {
  type QuicFrame (line 1011) | pub enum QuicFrame {
  type ConnectionCloseErrorSpace (line 1144) | pub enum ConnectionCloseErrorSpace {
  type TransportError (line 1151) | pub enum TransportError {
  type ApplicationError (line 1174) | pub struct ApplicationError(String);
  type CryptoError (line 1178) | pub struct CryptoError(u8);
    method deserialize (line 1190) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 1181) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: qevent/src/lib.rs
  type LogFile (line 23) | pub struct LogFile {
  type QlogFile (line 36) | pub struct QlogFile {
  type QlogFileSeq (line 50) | pub struct QlogFileSeq {
    constant SCHEMA (line 57) | pub const SCHEMA: &'static str = "urn:ietf:params:qlog:file:sequential";
  type Traces (line 63) | pub enum Traces {
  type Trace (line 79) | pub struct Trace {
  type TraceSeq (line 103) | pub struct TraceSeq {
  type CommonFields (line 114) | pub struct CommonFields {
  type VantagePoint (line 131) | pub struct VantagePoint {
  type VantagePointType (line 141) | pub enum VantagePointType {
    method from (line 153) | fn from(role: Role) -> Self {
  method fmt (line 162) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type TraceError (line 175) | pub struct TraceError {
  type Event (line 189) | pub struct Event {
  type PathID (line 217) | pub struct PathID(String);
  type ReferenceTime (line 227) | pub struct ReferenceTime {
    type Error (line 259) | type Error = &'static str;
    method try_from (line 260) | fn try_from(value: UncheckedReferenceTime) -> Result<Self, Self::Error> {
  type UncheckedReferenceTime (line 251) | struct UncheckedReferenceTime {
  type TimeClockType (line 277) | pub enum TimeClockType {
  type TimeEpoch (line 292) | pub enum TimeEpoch {
  method default (line 299) | fn default() -> Self {
  type RFC3339DateTime (line 306) | pub struct RFC3339DateTime(String);
  method default (line 309) | fn default() -> Self {
  type TimeFormat (line 316) | pub enum TimeFormat {
  type ProtocolTypeList (line 328) | pub struct ProtocolTypeList(Vec<ProtocolType>);
  type ProtocolType (line 332) | pub struct ProtocolType(String);
    method quic (line 335) | pub fn quic() -> ProtocolType {
    method http3 (line 339) | pub fn http3() -> ProtocolType {
  type GroupID (line 346) | pub struct GroupID(String);
    method from (line 349) | fn from(value: ConnectionId) -> Self {
    method from (line 355) | fn from(value: ConnectionID) -> Self {
    method from (line 361) | fn from(_value: (SocketAddr, SocketAddr)) -> Self {
  type SystemInformation (line 376) | pub struct SystemInformation {
  type EventImportance (line 383) | pub enum EventImportance {
  type EventData (line 392) | pub enum EventData {
  type BeSpecificEventData (line 473) | pub trait BeSpecificEventData {
    method scheme (line 474) | fn scheme() -> &'static str;
    method importance (line 476) | fn importance() -> EventImportance;
  type BeEventData (line 480) | pub trait BeEventData {
    method scheme (line 481) | fn scheme(&self) -> &'static str;
    method importance (line 483) | fn importance(&self) -> EventImportance;
    method scheme (line 488) | fn scheme(&self) -> &'static str {
    method importance (line 493) | fn importance(&self) -> EventImportance {
  type HexString (line 561) | pub struct HexString(#[serde_as(as = "serde_with::hex::Hex")] Bytes);
  method fmt (line 564) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type RawInfo (line 576) | pub struct RawInfo {
    method from (line 599) | fn from(data: D) -> Self {
  method data (line 592) | pub fn data<D: ContinuousData>(&mut self, data: D) -> &mut Self {
  type Error (line 654) | type Error = ();
  function try_from (line 656) | fn try_from(value: EventData) -> Result<Self, Self::Error> {
  function from (line 702) | fn from(value: TimeFormat) -> Self {
  function from (line 713) | fn from(value: ProtocolTypeList) -> Self {
  type Error (line 724) | type Error = ();
  function try_from (line 725) | fn try_from(mut event: Event) -> Result<Self, Self::Error> {
  function custom_fields (line 756) | fn custom_fields() {
  function event_data (line 804) | fn event_data() {
  function rollback (line 826) | fn rollback() {

FILE: qevent/src/loglevel.rs
  type Error (line 11) | pub struct Error {
  type Warning (line 23) | pub struct Warning {
  type Info (line 30) | pub struct Info {
  type Debug (line 36) | pub struct Debug {
  type Verbose (line 42) | pub struct Verbose {
  function from (line 59) | fn from(value: Error) -> Self {
  function from (line 68) | fn from(value: Warning) -> Self {
  function from (line 77) | fn from(value: Info) -> Self {
  function from (line 85) | fn from(value: Debug) -> Self {
  function from (line 93) | fn from(value: Verbose) -> Self {

FILE: qevent/src/packet.rs
  type PacketLogger (line 27) | struct PacketLogger {
    method record_frame (line 33) | pub fn record_frame(&mut self, frame: impl Into<QEventFrame>) {
    method log_sent (line 37) | pub fn log_sent(mut self, packet: &BasePacketWriter) {
  type PacketWriter (line 57) | pub struct PacketWriter<'b> {
  function as_ref (line 65) | fn as_ref(&self) -> &BasePacketWriter<'b> {
  function new_long (line 71) | pub fn new_long<S>(
  function new_short (line 101) | pub fn new_short(
  method remaining_mut (line 128) | fn remaining_mut(&self) -> usize {
  method advance_mut (line 133) | unsafe fn advance_mut(&mut self, cnt: usize) {
  method chunk_mut (line 138) | fn chunk_mut(&mut self) -> &mut UninitSlice {
  method put_bytes (line 143) | fn put_bytes(&mut self, val: u8, cnt: usize) {
  function record_frame (line 160) | fn record_frame(&mut self, frame: &F) {
  method encrypt_and_protect_packet (line 168) | fn encrypt_and_protect_packet(self) -> (usize, PacketInfo) {

FILE: qevent/src/quic.rs
  type QuicVersion (line 33) | pub struct QuicVersion(u32);
    method deserialize (line 48) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 36) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type ConnectionID (line 62) | pub struct ConnectionID(qbase::cid::ConnectionId);
    method deserialize (line 78) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 65) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Owner (line 97) | pub enum Owner {
  type IPAddress (line 111) | pub struct IPAddress(String);
  type IpVersion (line 116) | pub enum IpVersion {
  type PathEndpointInfo (line 137) | pub struct PathEndpointInfo {
    method from (line 151) | fn from(value: SocketAddr) -> Self {
  type PacketType (line 168) | pub enum PacketType {
    method from (line 182) | fn from(r#type: qbase::packet::Type) -> Self {
  type PacketNumberSpace (line 209) | pub enum PacketNumberSpace {
    method from (line 216) | fn from(value: qbase::Epoch) -> Self {
  type PacketHeader (line 229) | pub struct PacketHeader {
  method initial (line 273) | pub fn initial(&mut self, header: &InitialHeader) -> &mut Self {
  method handshake (line 288) | pub fn handshake(&mut self, header: &HandshakeHeader) -> &mut Self {
  method zero_rtt (line 299) | pub fn zero_rtt(&mut self, header: &ZeroRttHeader) -> &mut Self {
  method one_rtt (line 310) | pub fn one_rtt(&mut self, header: &OneRttHeader) -> &mut Self {
  method from (line 318) | fn from(header: &InitialHeader) -> Self {
  method from (line 326) | fn from(header: &HandshakeHeader) -> Self {
  method from (line 334) | fn from(header: &ZeroRttHeader) -> Self {
  method from (line 342) | fn from(header: &OneRttHeader) -> Self {
  type Token (line 358) | pub struct Token {
    type Error (line 370) | type Error = ();
    method try_from (line 371) | fn try_from(header: &qbase::packet::header::LongHeader<H>) -> Result<S...
  type TokenType (line 395) | pub enum TokenType {
  type StatelessResetToken (line 403) | pub struct StatelessResetToken(#[serde_as(as = "serde_with::hex::Hex")] ...
    method from (line 406) | fn from(value: qbase::token::ResetToken) -> Self {
  type KeyType (line 414) | pub enum KeyType {
  type ECN (line 431) | pub enum ECN {
  type QuicFrame (line 446) | pub enum QuicFrame {
    method from (line 610) | fn from(frame: &PingFrame) -> Self {
    method from (line 619) | fn from((frame, data): (&CryptoFrame, &D)) -> Self {
    method from (line 636) | fn from(frame: &CryptoFrame) -> Self {
    method from (line 652) | fn from((frame, data): (&StreamFrame, &D)) -> Self {
    method from (line 670) | fn from(frame: &StreamFrame) -> Self {
    method from (line 687) | fn from((frame, data): (&DatagramFrame, &D)) -> Self {
    method from (line 702) | fn from(frame: &DatagramFrame) -> Self {
    method from (line 716) | fn from(frame: &PathChallengeFrame) -> Self {
    method from (line 724) | fn from(frame: &PathResponseFrame) -> Self {
    method from (line 732) | fn from(frame: &AckFrame) -> Self {
    method from (line 762) | fn from(frame: &ReliableFrame) -> Self {
    method from (line 806) | fn from(value: &NewTokenFrame) -> Self {
    method from (line 821) | fn from(frame: &StreamCtlFrame) -> Self {
    method from (line 871) | fn from(frame: &ConnectionCloseFrame) -> Self {
    method from (line 902) | fn from(frame: &Frame<D>) -> Self {
  type QuicFramesCollector (line 946) | pub struct QuicFramesCollector<E> {
  function new (line 952) | pub fn new() -> Self {
  method default (line 961) | fn default() -> Self {
  function extend (line 971) | fn extend<T: IntoIterator<Item = F>>(&mut self, iter: T) {
  function from (line 1007) | fn from(value: QuicFramesCollector<E>) -> Self {
  type ApplicationCode (line 1014) | pub enum ApplicationCode {
  type StreamType (line 1032) | pub enum StreamType {
    method from (line 1038) | fn from(dir: qbase::sid::Dir) -> Self {
  type ConnectionCloseErrorSpace (line 1048) | pub enum ConnectionCloseErrorSpace {
  type ConnectionCloseErrorCode (line 1055) | pub enum ConnectionCloseErrorCode {
    method from (line 1020) | fn from(value: ApplicationCode) -> Self {
  type ConnectionCloseTriggerFrameType (line 1064) | pub enum ConnectionCloseTriggerFrameType {
  type TransportError (line 1072) | pub enum TransportError {
  type ApplicationError (line 1095) | pub struct ApplicationError(String);
  type CryptoError (line 1099) | pub struct CryptoError(u8);
    method deserialize (line 1117) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method fmt (line 1102) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method serialize (line 1108) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function from (line 1145) | fn from(value: IPAddress) -> Self {
  function from (line 1152) | fn from(value: IpVersion) -> Self {
  function from (line 1162) | fn from(value: ConnectionID) -> Self {
  function from (line 1169) | fn from(value: Owner) -> Self {
  function from (line 1179) | fn from(value: PacketType) -> Self {
  function from (line 1195) | fn from(value: PacketNumberSpace) -> Self {
  function from (line 1206) | fn from(value: TokenType) -> Self {
  function from (line 1216) | fn from(value: Token) -> Self {
  function from (line 1228) | fn from(value: StatelessResetToken) -> Self {
  function from (line 1239) | fn from(value: PacketHeader) -> Self {
  function from (line 1257) | fn from(value: TransportError) -> Self {
  function from (line 1288) | fn from(value: StreamType) -> Self {
  function from (line 1298) | fn from(value: ConnectionCloseErrorSpace) -> Self {
  type Error (line 1311) | type Error = ();
  function try_from (line 1313) | fn try_from(value: ConnectionCloseErrorCode) -> Result<Self, ()> {
  function from (line 1331) | fn from(value: ConnectionCloseTriggerFrameType) -> Self {
  function from (line 1344) | fn from(value: QuicFrame) -> Self {
  function from (line 1502) | fn from(value: ApplicationError) -> Self {
  function from (line 1509) | fn from(value: ApplicationCode) -> Self {
  function ack (line 1525) | fn ack() {

FILE: qevent/src/quic/connectivity.rs
  type ServerListening (line 23) | pub struct ServerListening {
  method address (line 40) | pub fn address(&mut self, socket_addr: SocketAddr) -> &mut Self {
  type ConnectionStarted (line 59) | pub struct ConnectionStarted {
    method default_protocol (line 95) | pub fn default_protocol() -> String {
  method socket (line 80) | pub fn socket(&mut self, (src, dst): (SocketAddr, SocketAddr)) -> &mut S...
  type ConnectionClosed (line 138) | pub struct ConnectionClosed {
  method ccf (line 149) | pub fn ccf(&mut self, ccf: &ConnectionCloseFrame) -> &mut Self {
  method quic_close_frame (line 156) | fn quic_close_frame(&mut self, frame: &QuicCloseFrame) -> &mut Connectio...
  method app_close_frame (line 161) | fn app_close_frame(&mut self, frame: &AppCloseFrame) -> &mut ConnectionC...
  method quic_error (line 166) | pub fn quic_error(&mut self, error: &QuicError) -> &mut Self {
  method app_error (line 171) | pub fn app_error(&mut self, error: &AppError) -> &mut Self {
  method error (line 176) | pub fn error(&mut self, error: &Error) {
  type ConnectionCode (line 186) | pub enum ConnectionCode {
    method from (line 203) | fn from(kind: ErrorKind) -> Self {
  function from (line 193) | fn from(value: ConnectionCode) -> Self {
  type ConnectionCloseTrigger (line 229) | pub enum ConnectionCloseTrigger {
  type ConnectionIdUpdated (line 257) | pub struct ConnectionIdUpdated {
  type SpinBitUpdated (line 275) | pub struct SpinBitUpdated {
  type ConnectionStateUpdated (line 299) | pub struct ConnectionStateUpdated {
  type ConnectionState (line 307) | pub enum ConnectionState {
  type BaseConnectionStates (line 314) | pub enum BaseConnectionStates {
  type GranularConnectionStates (line 331) | pub enum GranularConnectionStates {
  type PathAssigned (line 369) | pub struct PathAssigned {
  type MtuUpdated (line 387) | pub struct MtuUpdated {
  function from (line 416) | fn from(value: ServerListening) -> Self {
  function from (line 429) | fn from(value: ConnectionStarted) -> Self {
  function from (line 445) | fn from(value: CryptoError) -> Self {
  function from (line 452) | fn from(value: ConnectionCode) -> Self {
  type Error (line 463) | type Error = ();
  function try_from (line 465) | fn try_from(value: ConnectionCloseTrigger) -> Result<Self, ()> {
  function from (line 489) | fn from(value: ConnectionClosed) -> Self {
  function from (line 503) | fn from(value: ConnectionIdUpdated) -> Self {
  function from (line 514) | fn from(value: SpinBitUpdated) -> Self {
  function from (line 521) | fn from(value: ConnectionState) -> Self {
  function from (line 559) | fn from(value: ConnectionStateUpdated) -> Self {

FILE: qevent/src/quic/recovery.rs
  type RecoveryParametersSet (line 21) | pub struct RecoveryParametersSet {
  type RecoveryMetricsUpdated (line 84) | pub struct RecoveryMetricsUpdated {
  type CongestionStateUpdated (line 133) | pub struct CongestionStateUpdated {
  type LossTimerUpdated (line 163) | pub struct LossTimerUpdated {
  type TimerType (line 179) | pub enum TimerType {
  type EventType (line 186) | pub enum EventType {
  type PacketLost (line 208) | pub struct PacketLost {
  type PacketLostTrigger (line 221) | pub enum PacketLostTrigger {
  type MarkedForRetransmit (line 254) | pub struct MarkedForRetransmit {
  type ECNStateUpdated (line 266) | pub struct ECNStateUpdated {
  type ECNState (line 274) | pub enum ECNState {
  function from (line 303) | fn from(value: RecoveryParametersSet) -> Self {
  function from (line 320) | fn from(value: RecoveryMetricsUpdated) -> Self {
  function from (line 338) | fn from(value: CongestionStateUpdated) -> Self {
  function from (line 353) | fn from(value: TimerType) -> Self {
  function from (line 363) | fn from(value: EventType) -> Self {
  function from (line 373) | fn from(value: LossTimerUpdated) -> Self {
  function from (line 385) | fn from(value: PacketLostTrigger) -> Self {
  function from (line 399) | fn from(value: PacketLost) -> Self {
  function from (line 409) | fn from(value: MarkedForRetransmit) -> Self {

FILE: qevent/src/quic/security.rs
  type KeyUpdated (line 14) | pub struct KeyUpdated {
  type KeyUpdatedTrigger (line 29) | pub enum KeyUpdatedTrigger {
  type KeyDiscarded (line 44) | pub struct KeyDiscarded {
  type KeyDiscardedTrigger (line 57) | pub enum KeyDiscardedTrigger {
  function from (line 75) | fn from(value: KeyType) -> Self {
  function from (line 91) | fn from(value: KeyUpdatedTrigger) -> Self {
  function from (line 102) | fn from(value: KeyUpdated) -> Self {
  function from (line 117) | fn from(value: KeyDiscardedTrigger) -> Self {
  function from (line 130) | fn from(value: KeyDiscarded) -> Self {

FILE: qevent/src/quic/transport.rs
  type VersionInformation (line 36) | pub struct VersionInformation {
  type ALPNInformation (line 72) | pub struct ALPNInformation {
  type ALPNIdentifier (line 89) | pub struct ALPNIdentifier {
  type ParametersSet (line 137) | pub struct ParametersSet {
  method client_parameters (line 198) | pub fn client_parameters(&mut self, params: &ClientParameters) -> &mut S...
  method server_parameters (line 221) | pub fn server_parameters(&mut self, params: &ServerParameters) -> &mut S...
  type PreferredAddress (line 252) | pub struct PreferredAddress {
    method from (line 262) | fn from(pa: qbase::param::preferred_address::PreferredAddress) -> Self {
  type UnknownParameter (line 277) | pub struct UnknownParameter {
  type ParametersRestored (line 302) | pub struct ParametersRestored {
  method client_parameters (line 326) | pub fn client_parameters(&mut self, params: &ServerParameters) -> &mut S...
  type PacketSent (line 352) | pub struct PacketSent {
  type PacketSentTrigger (line 380) | pub enum PacketSentTrigger {
  type PacketReceived (line 395) | pub struct PacketReceived {
  type PacketReceivedTrigger (line 420) | pub enum PacketReceivedTrigger {
  type PacketDropped (line 441) | pub struct PacketDropped {
  type PacketDroppedTrigger (line 453) | pub enum PacketDroppedTrigger {
    method from (line 475) | fn from(value: qbase::packet::InvalidPacketNumber) -> Self {
    method from (line 485) | fn from(error: qbase::packet::error::Error) -> Self {
  type PacketBuffered (line 514) | pub struct PacketBuffered {
  type PacketBufferedTrigger (line 525) | pub enum PacketBufferedTrigger {
  type PacketsAcked (line 553) | pub struct PacketsAcked {
  type UdpDatagramsSent (line 571) | pub struct UdpDatagramsSent {
  type UdpDatagramsReceived (line 603) | pub struct UdpDatagramsReceived {
  type UdpDatagramDropped (line 636) | pub struct UdpDatagramDropped {
  type StreamStateUpdated (line 653) | pub struct StreamStateUpdated {
  type StreamState (line 669) | pub enum StreamState {
  type BaseStreamStates (line 676) | pub enum BaseStreamStates {
  type GranularStreamStates (line 684) | pub enum GranularStreamStates {
  type StreamSide (line 707) | pub enum StreamSide {
  type FramesProcessed (line 756) | pub struct FramesProcessed {
  type StreamDataMoved (line 804) | pub struct StreamDataMoved {
  type StreamDataLocation (line 821) | pub enum StreamDataLocation {
  type DataMovedAdditionalInfo (line 829) | pub enum DataMovedAdditionalInfo {
  type DatagramDataMoved (line 868) | pub struct DatagramDataMoved {
  type MigrationStateUpdated (line 896) | pub struct MigrationStateUpdated {
  type MigrationState (line 919) | pub enum MigrationState {
  function from (line 966) | fn from(value: QuicVersion) -> Self {
  function from (line 972) | fn from(vi: VersionInformation) -> Self {
  method from (line 990) | fn from(value: ALPNIdentifier) -> Self {
  function from (line 1003) | fn from(ai: ALPNInformation) -> Self {
  function from (line 1022) | fn from(pa: PreferredAddress) -> Self {
  function from (line 1035) | fn from(ps: ParametersSet) -> Self {
  function from (line 1067) | fn from(value: ParametersRestored) -> Self {
  function from (line 1087) | fn from(value: PacketSentTrigger) -> Self {
  function from (line 1099) | fn from(value: PacketSent) -> Self {
  function from (line 1120) | fn from(value: PacketReceivedTrigger) -> Self {
  function from (line 1128) | fn from(value: PacketReceived) -> Self {
  type Error (line 1148) | type Error = ();
  function try_from (line 1150) | fn try_from(value: PacketDroppedTrigger) -> Result<Self, ()> {
  function from (line 1169) | fn from(value: PacketDropped) -> Self {
  function from (line 1181) | fn from(value: PacketBufferedTrigger) -> Self {
  function from (line 1190) | fn from(value: PacketBuffered) -> Self {
  function from (line 1201) | fn from(value: PacketsAcked) -> Self {
  function from (line 1210) | fn from(value: UdpDatagramsSent) -> Self {
  function from (line 1220) | fn from(value: UdpDatagramsReceived) -> Self {
  function from (line 1230) | fn from(value: UdpDatagramDropped) -> Self {
  function from (line 1239) | fn from(value: StreamState) -> Self {
  function from (line 1267) | fn from(value: StreamSide) -> Self {
  function from (line 1276) | fn from(value: StreamStateUpdated) -> Self {
  function from (line 1288) | fn from(value: FramesProcessed) -> Self {
  function from (line 1303) | fn from(value: StreamDataLocation) -> Self {
  function from (line 1313) | fn from(value: StreamDataMoved) -> Self {

FILE: qevent/src/telemetry.rs
  type QLog (line 23) | pub trait QLog {
    method new_trace (line 24) | fn new_trace(&self, vantage_point: VantagePointType, group_id: GroupID...
  type ExportEvent (line 27) | pub trait ExportEvent: Send + Sync {
    method emit (line 28) | fn emit(&self, event: Event);
    method filter_event (line 30) | fn filter_event(&self, scheme: &'static str) -> bool {
    method filter_raw_data (line 35) | fn filter_raw_data(&self) -> bool {
  type Span (line 41) | pub struct Span {
    method emit (line 57) | pub fn emit(&self, event: Event) {
    method filter_event (line 62) | pub fn filter_event(&self, scheme: &'static str) -> bool {
    method filter_raw_data (line 67) | pub fn filter_raw_data(&self) -> bool {
    method load (line 72) | pub fn load<T: DeserializeOwned>(&self, name: &'static str) -> T {
    method try_load (line 89) | pub fn try_load<T: DeserializeOwned>(&self, name: &'static str) -> Opt...
    method enter (line 133) | pub fn enter(&self) -> Entered {
    method in_scope (line 144) | pub fn in_scope<T>(&self, f: impl FnOnce() -> T) -> T {
    method current (line 149) | pub fn current() -> Span {
  method fmt (line 47) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method eq (line 95) | fn eq(&self, other: &Self) -> bool {
  method default (line 101) | fn default() -> Self {
  type Entered (line 109) | pub struct Entered {
  method drop (line 123) | fn drop(&mut self) {
  type Instrument (line 163) | pub trait Instrument {
    method instrument (line 164) | fn instrument(self, span: Span) -> Instrumented<Self>;
    method instrument_in_current (line 166) | fn instrument_in_current(self) -> Instrumented<Self>;
    method instrument (line 170) | fn instrument(self, span: Span) -> Instrumented<Self> {
    method instrument_in_current (line 174) | fn instrument_in_current(self) -> Instrumented<Self> {
  type Output (line 180) | type Output = F::Output;
  method poll (line 182) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  function span_fields (line 202) | fn span_fields() {
  function event (line 224) | fn event() {

FILE: qevent/src/telemetry/filter.rs
  function event (line 3) | pub fn event(scheme: &'static str) -> bool {
  function event (line 9) | pub fn event(_scheme: &'static str) -> bool {
  function raw_data (line 15) | pub fn raw_data() -> bool {
  function raw_data (line 21) | pub fn raw_data() -> bool {

FILE: qevent/src/telemetry/handy.rs
  type NoopExporter (line 15) | pub struct NoopExporter;
  method emit (line 18) | fn emit(&self, event: Event) {
  method filter_event (line 22) | fn filter_event(&self, _: &'static str) -> bool {
  method filter_raw_data (line 26) | fn filter_raw_data(&self) -> bool {
  method emit (line 32) | fn emit(&self, event: Event) {
  type NoopLogger (line 37) | pub struct NoopLogger;
  method new_trace (line 41) | fn new_trace(&self, _: VantagePointType, _: GroupID) -> Span {
  method new_trace (line 48) | fn new_trace(&self, vantage_point: VantagePointType, group_id: GroupID) ...
  type TelemetryStorage (line 53) | pub trait TelemetryStorage {
    method join (line 54) | fn join(
    method join (line 61) | fn join(
    method join (line 85) | fn join(
    method join (line 95) | fn join(
  type LegacySeqLogger (line 103) | pub struct LegacySeqLogger<S> {
  method clone (line 108) | fn clone(&self) -> Self {
  function new (line 116) | pub fn new(storage: S) -> Self {
  method new_trace (line 122) | fn new_trace(&self, vantage_point: VantagePointType, group_id: GroupID) ...
  type TracingLogger (line 166) | pub struct TracingLogger;
  method new_trace (line 169) | fn new_trace(&self, vantage_point: VantagePointType, group_id: GroupID) ...
  function legacy_seq_exporter (line 212) | async fn legacy_seq_exporter() {

FILE: qevent/src/telemetry/macro_support.rs
  function new_span (line 7) | pub fn new_span(exporter: Arc<dyn ExportEvent>, fields: HashMap<&'static...
  function modify_event_builder_costom_fields (line 14) | pub fn modify_event_builder_costom_fields(
  function current_span_exporter (line 25) | pub fn current_span_exporter() -> Arc<dyn ExportEvent> {
  function current_span_fields (line 29) | pub fn current_span_fields() -> HashMap<&'static str, Value> {
  function try_load_current_span (line 33) | pub fn try_load_current_span<T: DeserializeOwned>(name: &'static str) ->...
  function build_and_emit_event (line 40) | pub fn build_and_emit_event<D: BeSpecificEventData>(
  function to_value (line 51) | pub fn to_value<T: Serialize>(value: T) -> Value {
  function from_value (line 55) | pub fn from_value<T: DeserializeOwned>(value: Value) -> T {

FILE: qinterface/examples/interface-monitor.rs
  function main (line 4) | async fn main() {

FILE: qinterface/src/bind_uri.rs
  type BindUri (line 14) | pub struct BindUri(http::Uri);
    type Error (line 74) | type Error = ParseError;
    method try_from (line 76) | fn try_from(uri: http::Uri) -> Result<Self, Self::Error> {
    method from (line 104) | fn from(value: String) -> Self {
    method from (line 114) | fn from(value: &str) -> Self {
    method from (line 124) | fn from(value: SocketAddr) -> Self {
    method from (line 134) | fn from(value: &T) -> Self {
    method from (line 141) | fn from(value: &BindUri) -> Self {
    constant TEMPORARY_PROP (line 147) | pub const TEMPORARY_PROP: &str = "temporary";
    constant STUN_PROP (line 148) | pub const STUN_PROP: &str = "stun";
    constant STUN_SERVER_PROP (line 149) | pub const STUN_SERVER_PROP: &str = "stun_server";
    constant RELAY_PROP (line 150) | pub const RELAY_PROP: &str = "relay";
    method scheme (line 152) | pub fn scheme(&self) -> Scheme {
    method as_uri (line 162) | pub fn as_uri(&self) -> &http::Uri {
    method family (line 166) | pub fn family(&self) -> Family {
    method as_iface_bind_uri (line 185) | pub fn as_iface_bind_uri(&self) -> Option<(Family, &str, u16)> {
    method as_inet_bind_uri (line 192) | pub fn as_inet_bind_uri(&self) -> Option<SocketAddr> {
    method add_prop (line 199) | pub fn add_prop(&mut self, key: &str, value: &str) {
    constant ALLOC_PORT_ID (line 213) | pub const ALLOC_PORT_ID: &'static str = "alloc_port_id";
    method alloc_port (line 215) | pub fn alloc_port(&self) -> Self {
    method prop (line 241) | pub fn prop(&self, key: &str) -> Option<Cow<'_, str>> {
    method is_temporary (line 253) | pub fn is_temporary(&self) -> bool {
    method enable_stun (line 260) | pub fn enable_stun(&mut self) {
    method is_stun_enabled (line 264) | pub fn is_stun_enabled(&self) -> bool {
    method with_stun_server (line 271) | pub fn with_stun_server(mut self, stun_server: &str) -> Self {
    method stun_server (line 276) | pub fn stun_server(&self) -> Option<Cow<'_, str>> {
    method with_relay (line 281) | pub fn with_relay(mut self, relay: &str) -> Self {
    method relay (line 286) | pub fn relay(&self) -> Option<Cow<'_, str>> {
    method identity_key (line 295) | pub fn identity_key(&self) -> String {
    method resolve (line 308) | pub fn resolve(&self) -> Result<SocketAddr, io::Error> {
  type ParseError (line 17) | pub enum ParseError {
  function parse_iface_bind_uri (line 36) | fn parse_iface_bind_uri(uri: &http::Uri) -> Result<(Family, &str, u16), ...
  function parse_inet_bind_uri (line 47) | fn parse_inet_bind_uri(uri: &http::Uri) -> Result<SocketAddr, ParseError> {
  type Err (line 61) | type Err = ParseError;
  method from_str (line 63) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type Error (line 335) | type Error = io::Error;
  method try_from (line 337) | fn try_from(bind_uri: &BindUri) -> Result<Self, Self::Error> {
  type Error (line 343) | type Error = io::Error;
  method try_from (line 345) | fn try_from(bind_uri: BindUri) -> Result<Self, Self::Error> {
  type Scheme (line 351) | pub enum Scheme {
    method to_str (line 357) | pub const fn to_str(&self) -> &'static str {
  function from (line 366) | fn from(value: Scheme) -> Self {
  type Err (line 375) | type Err = String;
  method from_str (line 377) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 387) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function invalid_uri (line 397) | fn invalid_uri() {
  function missing_scheme (line 405) | fn missing_scheme() {
  function invalid_scheme (line 413) | fn invalid_scheme() {
  function has_path (line 421) | fn has_path() {
  function missing_ip_family (line 429) | fn missing_ip_family() {
  function missing_port (line 437) | fn missing_port() {
  function invalid_ip_family (line 445) | fn invalid_ip_family() {
  function invalid_ip_addr (line 453) | fn invalid_ip_addr() {
  function iface_bind_uri (line 461) | fn iface_bind_uri() {
  function inet_bind_uri (line 475) | fn inet_bind_uri() {
  function interface_not_found (line 488) | async fn interface_not_found() {
  function to_socket_addr (line 497) | fn to_socket_addr() {
  function alloc_port (line 506) | fn alloc_port() {
  function alloc_port_for_non_zero_port1 (line 513) | fn alloc_port_for_non_zero_port1() {
  function alloc_port_for_non_zero_port2 (line 520) | fn alloc_port_for_non_zero_port2() {
  function temporary (line 526) | fn temporary() {
  function stun_enabled (line 547) | fn stun_enabled() {
  function stun_server (line 562) | fn stun_server() {
  function relay (line 578) | fn relay() {

FILE: qinterface/src/component.rs
  type Component (line 15) | pub trait Component: Any + Debug + Send + Sync {
    method poll_shutdown (line 17) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()>;
    method reinit (line 25) | fn reinit(&self, iface: &Interface);
  type IdHasher (line 32) | pub(super) struct IdHasher(u64);
  method write (line 35) | fn write(&mut self, _: &[u8]) {
  method write_u64 (line 40) | fn write_u64(&mut self, id: u64) {
  method finish (line 45) | fn finish(&self) -> u64 {
  type Components (line 51) | pub struct Components {
    method new (line 56) | pub fn new() -> Self {
    method get (line 60) | pub fn get<C: Component>(&self) -> Option<&C> {
    method exist (line 66) | pub fn exist<C: Component>(&self) -> bool {
    method with (line 70) | pub fn with<C: Component, T>(&self, f: impl FnOnce(&C) -> T) -> Option...
    method init_with (line 74) | pub fn init_with<C: Component>(&mut self, init: impl FnOnce() -> C) ->...
    method try_init_with (line 82) | pub fn try_init_with<C: Component, E>(
    method poll_remove (line 94) | pub fn poll_remove<C>(&mut self, cx: &mut Context<'_>) -> Poll<()>

FILE: qinterface/src/component/alive.rs
  type InterfaceFailure (line 23) | pub enum InterfaceFailure {
    method from (line 37) | fn from(error: io::Error) -> Self {
    method is_recoverable (line 43) | pub fn is_recoverable(&self) -> bool {
  function is_alive (line 51) | pub async fn is_alive(iface: &(impl IO + ?Sized)) -> Result<(), Interfac...
  type RebindOnNetworkChangedComponent (line 94) | pub struct RebindOnNetworkChangedComponent {
    method new (line 100) | pub fn new(iface: &Interface, devices: &'static Devices) -> Self {
    method lock_task (line 109) | fn lock_task(&self) -> MutexGuard<'_, Option<AbortOnDropHandle<()>>> {
    method init (line 115) | fn init(&self, iface: &Interface) {
  method poll_shutdown (line 155) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 165) | fn reinit(&self, iface: &Interface) {

FILE: qinterface/src/component/location.rs
  type AddressEvent (line 21) | pub enum AddressEvent<D: ?Sized = dyn Any + Send + Sync> {
    method downcast (line 39) | pub fn downcast<D: Any + Send + Sync>(self) -> Result<AddressEvent<D>,...
  method clone (line 28) | fn clone(&self) -> Self {
  type EventSender (line 54) | type EventSender = mpsc::UnboundedSender<(BindUri, AddressEvent)>;
  type EventReceiver (line 55) | type EventReceiver = mpsc::UnboundedReceiver<(BindUri, AddressEvent)>;
  type EventPublisher (line 57) | struct EventPublisher {
    method new (line 64) | pub fn new() -> Self {
    method publish_event (line 72) | pub fn publish_event(&mut self, bind_uri: BindUri, event: AddressEvent) {
    method register_subscriber (line 98) | pub fn register_subscriber(&mut self, subscriber: EventSender) {
  type Locations (line 114) | pub struct Locations {
    method new (line 127) | pub fn new() -> Self {
    method global (line 154) | pub fn global() -> &'static Arc<Self> {
    method publish (line 159) | pub fn publish(&self, bind_uri: BindUri, event: AddressEvent) {
    method upsert (line 163) | pub fn upsert<D: Any + Send + Sync + Debug>(&self, bind_uri: BindUri, ...
    method remove (line 167) | pub fn remove<D: Any + Send + Sync>(&self, bind_uri: BindUri) {
    method close (line 171) | pub fn close(&self, bind_uri: BindUri) {
    method subscribe (line 175) | pub fn subscribe(&self) -> Observer {
  method default (line 121) | fn default() -> Self {
  type Observer (line 183) | pub struct Observer {
    method recv (line 188) | pub async fn recv(&mut self) -> Option<(BindUri, AddressEvent)> {
    method try_recv (line 192) | pub fn try_recv(&mut self) -> Result<(BindUri, AddressEvent), mpsc::er...
  type IfaceLocations (line 198) | pub struct IfaceLocations<I> {
  function new (line 204) | pub fn new(ref_iface: I, locations: Arc<Locations>) -> Self {
  function lock_ref_iface (line 216) | fn lock_ref_iface(&self) -> MutexGuard<'_, I> {
  function r#for (line 221) | pub fn r#for<R>(&self, ref_iface: &R, f: impl FnOnce(&Locations, BindUri))
  type LocationsComponent (line 237) | pub type LocationsComponent = IfaceLocations<WeakInterface>;
  method poll_shutdown (line 240) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 245) | fn reinit(&self, iface: &Interface) {

FILE: qinterface/src/component/route.rs
  type Way (line 23) | pub type Way = (BindUri, Pathway, Link);
  type QuicRouter (line 31) | pub struct QuicRouter {
    method global (line 37) | pub fn global() -> &'static Arc<Self> {
    method new (line 47) | pub fn new() -> Self {
    method insert (line 55) | pub fn insert(
    method remove (line 68) | pub fn remove(&self, signpost: &Signpost) {
    method find_entry (line 72) | fn find_entry(&self, packet: &Packet, link: &Link) -> Option<Arc<RcvdP...
    method try_deliver (line 88) | pub async fn try_deliver(&self, packet: Packet, way: Way) -> Result<()...
    method deliver (line 98) | pub async fn deliver(&self, packet: Packet, way: Way) {
    method on_connectless_packets (line 124) | pub fn on_connectless_packets<S>(&self, sink: S) -> bool
    method is_connectless_draining (line 136) | pub fn is_connectless_draining(&self) -> bool {
    method drain_connectless (line 140) | pub fn drain_connectless(&self) {
    method registry_on_issuing_scid (line 144) | pub fn registry_on_issuing_scid<T>(
  method default (line 158) | fn default() -> Self {
  type Signpost (line 164) | pub struct Signpost {
    method from (line 170) | fn from(value: ConnectionId) -> Self {
    method from (line 179) | fn from(value: SocketAddr) -> Self {
  type QuicRouterEntry (line 188) | pub struct QuicRouterEntry {
    method signpost (line 195) | pub fn signpost(&self) -> Signpost {
    method remove (line 199) | pub fn remove(&self) {
  method drop (line 209) | fn drop(&mut self) {
  type QuicRouterRegistry (line 215) | pub struct QuicRouterRegistry<TX> {
  method gen_unique_cid (line 225) | fn gen_unique_cid(&self) -> ConnectionId {
  method retire_cid (line 246) | fn retire_cid(&self, cid: ConnectionId) {
  function send_frame (line 255) | fn send_frame<I: IntoIterator<Item = NewConnectionIdFrame>>(&self, iter:...
  type Output (line 264) | type Output = ();
  function recv_frame (line 266) | fn recv_frame(&self, frame: RetireConnectionIdFrame) -> Result<Self::Out...
  type QuicRouterComponent (line 272) | pub struct QuicRouterComponent {
    method new (line 277) | pub fn new(router: Arc<QuicRouter>) -> Self {
    method router (line 281) | pub fn router(&self) -> Arc<QuicRouter> {
  method reinit (line 287) | fn reinit(&self, _quic_iface: &Interface) {}
  method poll_shutdown (line 289) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {

FILE: qinterface/src/component/route/handler.rs
  type PacketSink (line 7) | pub type PacketSink<P = Packet> = Box<dyn Fn(P, Way) + Send>;
  type PacketHandler (line 9) | pub struct PacketHandler<P = Packet>(Mutex<Option<PacketSink<P>>>);
  function fmt (line 12) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 18) | fn default() -> Self {
  function new (line 24) | pub fn new<S>(sink: PacketSink<P>) -> Self {
  function lock (line 28) | pub(crate) fn lock(&self) -> MutexGuard<'_, Option<PacketSink<P>>> {
  function drain (line 32) | pub fn drain() -> PacketHandler<P> {
  function update (line 36) | pub fn update(&self, handler: PacketSink<P>) {
  function is_drain (line 40) | pub fn is_drain(&self) -> bool {
  function take (line 44) | pub fn take(&self) -> Option<PacketSink<P>> {
  function deliver (line 48) | pub fn deliver(&self, packet: P, way: Way) {
  function deliver_packets (line 54) | pub fn deliver_packets(&self, packets: impl IntoIterator<Item = (P, Way)...

FILE: qinterface/src/component/route/packet.rs
  type CipherPacket (line 21) | pub struct CipherPacket<H> {
  function new (line 32) | pub fn new(header: H, payload: BytesMut, payload_offset: usize) -> Self {
  function header (line 40) | pub fn header(&self) -> &H {
  function qlog_header (line 44) | fn qlog_header(&self) -> PacketHeader {
  function drop_on_key_unavailable (line 48) | pub fn drop_on_key_unavailable(self) {
  function drop_on_remove_header_protection_failure (line 56) | fn drop_on_remove_header_protection_failure(self) {
  function drop_on_decryption_failure (line 69) | fn drop_on_decryption_failure(self, error: qbase::packet::error::Error, ...
  function drop_on_reverse_bit_error (line 87) | fn drop_on_reverse_bit_error(self, error: &qbase::packet::error::Error) {
  function drop_on_invalid_pn (line 101) | fn drop_on_invalid_pn(self, invalid_pn: InvalidPacketNumber) {
  function payload_len (line 115) | pub fn payload_len(&self) -> usize {
  function decrypt_long_packet (line 119) | pub fn decrypt_long_packet(
  function decrypt_short_packet (line 164) | pub fn decrypt_short_packet(
  function drop_on_scid_unmatch (line 212) | pub fn drop_on_scid_unmatch(self) {
  type PlainPacket (line 227) | pub struct PlainPacket<H> {
  function size (line 238) | pub fn size(&self) -> usize {
  function pn (line 242) | pub fn pn(&self) -> u64 {
  function payload_len (line 246) | pub fn payload_len(&self) -> usize {
  function body (line 250) | pub fn body(&self) -> Bytes {
  function raw_info (line 256) | pub fn raw_info(&self) -> qevent::RawInfo {
  function qlog_header (line 269) | pub fn qlog_header(&self) -> PacketHeader {
  function drop_on_interface_not_found (line 278) | pub fn drop_on_interface_not_found(self) {
  function drop_on_conenction_closed (line 291) | pub fn drop_on_conenction_closed(self) {
  function log_received (line 304) | pub fn log_received(&self, frames: impl Into<Vec<QuicFrame>>) {

FILE: qinterface/src/component/route/queue.rs
  type PacketQueue (line 11) | type PacketQueue<P> = BoundQueue<(CipherPacket<P>, Way)>;
  type RcvdPacketQueue (line 15) | pub struct RcvdPacketQueue {
    method new (line 30) | pub fn new() -> Self {
    method initial (line 39) | pub fn initial(&self) -> &PacketQueue<long::InitialHeader> {
    method handshake (line 43) | pub fn handshake(&self) -> &PacketQueue<long::HandshakeHeader> {
    method zero_rtt (line 47) | pub fn zero_rtt(&self) -> &PacketQueue<long::ZeroRttHeader> {
    method one_rtt (line 51) | pub fn one_rtt(&self) -> &PacketQueue<short::OneRttHeader> {
    method close_all (line 55) | pub fn close_all(&self) {
    method deliver (line 62) | pub async fn deliver(&self, packet: Packet, way: Way) {
  method default (line 24) | fn default() -> Self {

FILE: qinterface/src/device.rs
  type InterfaceEvent (line 25) | pub enum InterfaceEvent {
    method device (line 42) | pub fn device(&self) -> &str {
    method old_interface (line 50) | pub fn old_interface(&self) -> Option<&Interface> {
    method new_interface (line 58) | pub fn new_interface(&self) -> Option<&Interface> {
    method from_update (line 68) | pub fn from_update<'i>(
  function scan_interfaces (line 100) | fn scan_interfaces() -> HashMap<String, Interface> {
  type SubscribersMap (line 116) | type SubscribersMap = RwLock<HashMap<UniqueId, UnboundedSender<Arc<Inter...
  type InterfacesMap (line 117) | type InterfacesMap = RwLock<HashMap<String, Interface>>;
  type InterfaceEventReceiver (line 120) | pub struct InterfaceEventReceiver {
  method drop (line 129) | fn drop(&mut self) {
  type InterfacesMonitor (line 134) | pub struct InterfacesMonitor {
    method update (line 141) | pub async fn update(&mut self) -> Option<(&HashMap<String, Interface>,...
    method try_update (line 168) | pub fn try_update(&mut self) -> Option<(&HashMap<String, Interface>, A...
    method interfaces (line 195) | pub fn interfaces(&self) -> &HashMap<String, Interface> {
    method into_inner (line 199) | pub fn into_inner(self) -> (HashMap<String, Interface>, InterfaceEvent...
  type State (line 205) | struct State {
    method check_network_changes (line 222) | fn check_network_changes(&self) {
    method monitor (line 236) | fn monitor(&self) -> (HashMap<String, Interface>, InterfaceEventReceiv...
    method event_receiver (line 254) | fn event_receiver(&self) -> InterfaceEventReceiver {
    method interfaces (line 267) | fn interfaces(&self) -> HashMap<String, Interface> {
    method get (line 271) | fn get(&self, name: &str) -> Option<Interface> {
  method default (line 212) | fn default() -> Self {
  type Devices (line 276) | pub struct Devices {
    method global (line 293) | pub fn global() -> &'static Devices {
    method new (line 298) | pub fn new() -> Self {
    method restart_watcher (line 333) | pub fn restart_watcher(&self) -> Result<(), WatcherError> {
    method on_interface_changed (line 346) | pub fn on_interface_changed(&self) {
    method monitor (line 351) | pub fn monitor(&self) -> InterfacesMonitor {
    method event_receiver (line 360) | pub fn event_receiver(&self) -> InterfaceEventReceiver {
    method interfaces (line 365) | pub fn interfaces(&self) -> HashMap<String, Interface> {
    method get (line 369) | pub fn get(&self, name: &str) -> Option<Interface> {
    method resolve (line 373) | pub fn resolve(&self, device: &str, family: Family) -> Option<IpAddr> {
  method fmt (line 283) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 393) | fn default() -> Self {

FILE: qinterface/src/io.rs
  type IO (line 32) | pub trait IO: Send + Sync + Any {
    method bind_uri (line 37) | fn bind_uri(&self) -> BindUri;
    method bound_addr (line 50) | fn bound_addr(&self) -> io::Result<SocketAddr>;
    method max_segment_size (line 53) | fn max_segment_size(&self) -> io::Result<usize>;
    method max_segments (line 56) | fn max_segments(&self) -> io::Result<usize>;
    method poll_send (line 62) | fn poll_send(
    method poll_recv (line 74) | fn poll_recv(
    method poll_close (line 90) | fn poll_close(&mut self, cx: &mut Context) -> Poll<io::Result<()>>;
  type IoExt (line 93) | pub trait IoExt: IO {
    method sendmmsg (line 95) | fn sendmmsg(
    method recvmmsg (line 109) | fn recvmmsg<'b>(
    method close (line 135) | fn close(&mut self) -> impl Future<Output = io::Result<()>> + Send {
  type RefIO (line 142) | pub trait RefIO: Clone + Send + Sync {
    method iface (line 145) | fn iface(&self) -> &Self::Interface;
    method same_io (line 147) | fn same_io(&self, other: &Self) -> bool;
    type Interface (line 151) | type Interface = I;
    method iface (line 154) | fn iface(&self) -> &Self::Interface {
    method same_io (line 158) | fn same_io(&self, other: &Self) -> bool {

FILE: qinterface/src/io/factory.rs
  type ProductIO (line 5) | pub trait ProductIO: Send + Sync {
    method bind (line 6) | fn bind(&self, bind_uri: BindUri) -> Box<dyn IO>;
    method poll_rebind (line 8) | fn poll_rebind(&self, cx: &mut Context<'_>, quic_io: &mut Box<dyn IO>)...
    method bind (line 27) | fn bind(&self, bind_uri: BindUri) -> Box<dyn IO> {
  type ProductIoExt (line 15) | pub trait ProductIoExt: ProductIO {
    method rebind (line 16) | fn rebind(&self, quic_io: &mut Box<dyn IO>) -> impl Future<Output = ()> {

FILE: qinterface/src/io/handy.rs
  type UdpSocketController (line 24) | pub struct UdpSocketController {
    method bind (line 63) | pub fn bind(bind_uri: BindUri) -> Self {
    method usc (line 80) | fn usc(&self) -> io::Result<&qudp::UdpSocket> {
  type Closed (line 33) | pub struct Closed(());
  function from (line 36) | fn from(error: Closed) -> Self {
  type BindFailed (line 42) | pub struct BindFailed(Arc<io::Error>);
  method fmt (line 45) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method source (line 51) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  function from (line 57) | fn from(error: BindFailed) -> Self {
  method bind_uri (line 89) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 93) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segments (line 97) | fn max_segments(&self) -> io::Result<usize> {
  method max_segment_size (line 101) | fn max_segment_size(&self) -> io::Result<usize> {
  method poll_send (line 105) | fn poll_send(
  method poll_recv (line 118) | fn poll_recv(
  method poll_close (line 147) | fn poll_close(&mut self, _cx: &mut Context) -> Poll<io::Result<()>> {
  type Unsupported (line 171) | pub struct Unsupported {
    method bind (line 188) | pub fn bind(bind_uri: BindUri) -> Self {
  type UnsupportedError (line 179) | pub struct UnsupportedError(());
  function from (line 182) | fn from(error: UnsupportedError) -> Self {
  method bind_uri (line 194) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 198) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segment_size (line 202) | fn max_segment_size(&self) -> io::Result<usize> {
  method max_segments (line 206) | fn max_segments(&self) -> io::Result<usize> {
  method poll_send (line 210) | fn poll_send(
  method poll_recv (line 219) | fn poll_recv(
  method poll_close (line 228) | fn poll_close(&mut self, _: &mut Context) -> Poll<io::Result<()>> {
  constant _ (line 242) | const _: () = {

FILE: qinterface/src/lib.rs
  type BindInterface (line 26) | pub struct BindInterface {
    method new (line 31) | pub(crate) fn new(iface: InterfaceContext) -> Self {
    method bind_uri (line 37) | pub fn bind_uri(&self) -> BindUri {
    method close (line 41) | pub fn close(&self) -> impl Future<Output = std::io::Result<()>> + Send {
    method rebind (line 45) | pub fn rebind(&self) -> impl Future<Output = ()> + Send {
    method borrow (line 50) | pub fn borrow(&self) -> Interface {
    method downgrade (line 58) | pub fn downgrade(&self) -> WeakBindInterface {
    method borrow_weak (line 65) | pub fn borrow_weak(&self) -> WeakInterface {
  type Interface (line 71) | pub struct Interface {
    method with_io (line 102) | fn with_io<T>(&self, f: impl FnOnce(&dyn IO) -> T) -> std::io::Result<...
    method bind_interface (line 110) | pub fn bind_interface(&self) -> &BindInterface {
    method downgrade (line 115) | pub fn downgrade(&self) -> WeakInterface {
    method same_io (line 123) | pub fn same_io(&self, other: &Interface) -> bool {
  type RebindedError (line 78) | pub struct RebindedError;
    method is_source_of (line 81) | pub fn is_source_of(mut error: &(dyn Error + 'static)) -> bool {
  function from (line 95) | fn from(value: RebindedError) -> Self {
  type Interface (line 130) | type Interface = Self;
  method iface (line 133) | fn iface(&self) -> &Self::Interface {
  method same_io (line 137) | fn same_io(&self, other: &Self) -> bool {
  method bind_uri (line 144) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 149) | fn bound_addr(&self) -> std::io::Result<SocketAddr> {
  method max_segment_size (line 154) | fn max_segment_size(&self) -> std::io::Result<usize> {
  method max_segments (line 159) | fn max_segments(&self) -> std::io::Result<usize> {
  method poll_send (line 164) | fn poll_send(
  method poll_recv (line 174) | fn poll_recv(
  method poll_close (line 184) | fn poll_close(&mut self, cx: &mut Context) -> Poll<std::io::Result<()>> {
  type UnboundError (line 191) | pub struct UnboundError;
    method is_source_of (line 194) | pub fn is_source_of(mut error: &(dyn Error + 'static)) -> bool {
  function from (line 208) | fn from(value: UnboundError) -> Self {
  type WeakBindInterface (line 214) | pub struct WeakBindInterface {
    method upgrade (line 219) | pub fn upgrade(&self) -> Result<BindInterface, UnboundError> {
    method borrow (line 225) | pub fn borrow(&self) -> Result<WeakInterface, UnboundError> {
    method same_io (line 229) | pub fn same_io(&self, other: &WeakBindInterface) -> bool {
  type WeakInterface (line 235) | pub struct WeakInterface {
    method from (line 242) | fn from(iface: Interface) -> Self {
    method upgrade (line 248) | pub fn upgrade(&self) -> Result<Interface, UnboundError> {
    method same_io (line 255) | pub fn same_io(&self, other: &WeakInterface) -> bool {
  type Interface (line 261) | type Interface = WeakInterface;
  method iface (line 263) | fn iface(&self) -> &Self::Interface {
  method same_io (line 267) | fn same_io(&self, other: &Self) -> bool {
  method bind_uri (line 273) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 277) | fn bound_addr(&self) -> std::io::Result<SocketAddr> {
  method max_segment_size (line 281) | fn max_segment_size(&self) -> std::io::Result<usize> {
  method max_segments (line 285) | fn max_segments(&self) -> std::io::Result<usize> {
  method poll_send (line 289) | fn poll_send(
  method poll_recv (line 298) | fn poll_recv(
  method poll_close (line 307) | fn poll_close(&mut self, cx: &mut Context) -> Poll<std::io::Result<()>> {

FILE: qinterface/src/manager.rs
  type InterfaceManager (line 40) | pub struct InterfaceManager {
    method global (line 66) | pub fn global() -> &'static Arc<Self> {
    method new (line 72) | pub fn new() -> Self {
    method new_binding (line 76) | fn new_binding(
    method bind (line 103) | pub async fn bind(
    method borrow (line 135) | pub fn borrow(&self, bind_uri: &BindUri) -> Option<Interface> {
    method get (line 142) | pub fn get(&self, bind_uri: &BindUri) -> Option<BindInterface> {
    method unbind (line 149) | pub fn unbind(self: &Arc<Self>, bind_uri: BindUri) -> impl Future<Outp...
  type InterfaceEntry (line 46) | struct InterfaceEntry {
    method is_dropped (line 52) | fn is_dropped(&self) -> bool {
    method dropped (line 56) | fn dropped(&self) -> impl Future<Output = ()> + use<> {
  type SpawnOnDrop (line 175) | pub(crate) struct SpawnOnDrop<F: Future<Output: Send + 'static> + Unpin ...
  function new (line 180) | pub(crate) fn new(future: F) -> Self {
  type Output (line 188) | type Output = F::Output;
  method poll (line 190) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...
  method drop (line 203) | fn drop(&mut self) {
  type Binding (line 212) | struct Binding {
    method new (line 219) | fn new(io: Box<dyn IO>, id: UniqueId) -> Self {
    method is_dropping (line 505) | pub fn is_dropping(&self) -> bool {
    method take_io (line 509) | pub fn take_io(&mut self) -> Option<Box<dyn IO>> {
  type InterfaceContext (line 231) | pub struct InterfaceContext {
    method binding (line 241) | fn binding(&self) -> RwLockReadGuard<'_, Binding> {
    method binding_mut (line 245) | fn binding_mut(&self) -> RwLockWriteGuard<'_, Binding> {
    method bind_id (line 249) | pub fn bind_id(&self) -> UniqueId {
    method with_io (line 253) | fn with_io<T>(&self, f: impl FnOnce(&dyn IO) -> T) -> T {
    method with_bind_io (line 259) | pub(crate) fn with_bind_io<T>(
    method components (line 272) | fn components(&self) -> RwLockReadGuard<'_, Components> {
    method components_mut (line 276) | fn components_mut(&self) -> RwLockWriteGuard<'_, Components> {
    method poll_close (line 280) | pub fn poll_close(&self, cx: &mut Context) -> Poll<io::Result<()>> {
    method drop (line 520) | fn drop(&self) -> impl Future<Output = ()> + Send + use<> {
  method fmt (line 290) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method poll_rebind (line 298) | pub fn poll_rebind(&self, cx: &mut Context<'_>) -> Poll<()> {
  method insert_component_with (line 336) | pub fn insert_component_with<C: Component>(&self, init: impl FnOnce(&Int...
  method with_components (line 342) | pub fn with_components<T>(&self, f: impl FnOnce(&Components, &Interface)...
  method with_components_mut (line 354) | pub fn with_components_mut<T>(&self, f: impl FnOnce(&mut Components, &In...
  method with_component (line 368) | pub fn with_component<C: Component, T>(
  method with_components (line 383) | pub fn with_components<T>(&self, f: impl FnOnce(&Components) -> T) -> Re...
  method get_component (line 395) | pub fn get_component<C: Component + Clone>(&self) -> Result<Option<C>, R...
  method bind_uri (line 401) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 405) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segment_size (line 409) | fn max_segment_size(&self) -> io::Result<usize> {
  method max_segments (line 413) | fn max_segments(&self) -> io::Result<usize> {
  method poll_send (line 417) | fn poll_send(
  method poll_recv (line 426) | fn poll_recv(
  method poll_close (line 435) | fn poll_close(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
  type DroppingIO (line 447) | pub(crate) struct DroppingIO {
    method to_io_error (line 452) | pub(crate) fn to_io_error(&self) -> io::Error {
  function from (line 458) | fn from(error: DroppingIO) -> Self {
  method bind_uri (line 464) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 468) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segment_size (line 472) | fn max_segment_size(&self) -> io::Result<usize> {
  method max_segments (line 476) | fn max_segments(&self) -> io::Result<usize> {
  method poll_send (line 480) | fn poll_send(
  method poll_recv (line 489) | fn poll_recv(
  method poll_close (line 498) | fn poll_close(&mut self, _: &mut Context) -> Poll<io::Result<()>> {
  method drop (line 548) | fn drop(&mut self) {
  type TestComponent (line 575) | struct TestComponent {
  method poll_shutdown (line 580) | fn poll_shutdown(&self, _cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 585) | fn reinit(&self, _iface: &crate::Interface) {}
  type TestIo (line 589) | struct TestIo {
  method bind_uri (line 595) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 599) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segment_size (line 603) | fn max_segment_size(&self) -> io::Result<usize> {
  method max_segments (line 607) | fn max_segments(&self) -> io::Result<usize> {
  method poll_send (line 611) | fn poll_send(
  method poll_recv (line 620) | fn poll_recv(
  method poll_close (line 629) | fn poll_close(&mut self, _cx: &mut Context) -> Poll<io::Result<()>> {
  type TestFactory (line 636) | struct TestFactory {
  method bind (line 641) | fn bind(&self, bind_uri: BindUri) -> Box<dyn IO> {
  function binding_take_io_is_idempotent_and_switches_to_dropping_io (line 650) | fn binding_take_io_is_idempotent_and_switches_to_dropping_io() {
  function poll_close_shuts_down_components_before_io_close (line 674) | fn poll_close_shuts_down_components_before_io_close() {

FILE: qinterface/tests/auto_rebind.rs
  function rebind_on_network_changed_triggers_on_recoverable_failure (line 12) | fn rebind_on_network_changed_triggers_on_recoverable_failure() {

FILE: qinterface/tests/common/mod.rs
  function run (line 20) | pub fn run<F: Future>(future: F) -> F::Output {
  function test_bind_uri (line 36) | pub fn test_bind_uri() -> BindUri {
  function any_iface_bind_uri (line 42) | pub fn any_iface_bind_uri() -> Option<BindUri> {
  type FakeIoState (line 64) | pub struct FakeIoState {
  type FakeIo (line 70) | pub struct FakeIo {
    method new (line 79) | pub fn new(bind_uri: BindUri, bound_addr: SocketAddr, state: Arc<FakeI...
    method close_notify (line 89) | pub fn close_notify(&self) -> Arc<Notify> {
  method bind_uri (line 95) | fn bind_uri(&self) -> BindUri {
  method bound_addr (line 99) | fn bound_addr(&self) -> io::Result<SocketAddr> {
  method max_segment_size (line 103) | fn max_segment_size(&self) -> io::Result<usize> {
  method max_segments (line 107) | fn max_segments(&self) -> io::Result<usize> {
  method poll_send (line 111) | fn poll_send(
  method poll_recv (line 120) | fn poll_recv(
  method poll_close (line 129) | fn poll_close(&mut self, _cx: &mut Context) -> Poll<io::Result<()>> {
  type FakeFactory (line 139) | pub struct FakeFactory {
    method new (line 145) | pub fn new() -> Self {
    method bind (line 154) | fn bind(&self, bind_uri: BindUri) -> Box<dyn IO> {
  type ProbeEventKind (line 165) | pub enum ProbeEventKind {
  type ProbeEvent (line 171) | pub struct ProbeEvent {
  type Probe (line 177) | pub struct Probe {
  type ProbeComponent (line 185) | pub struct ProbeComponent {
    method new (line 190) | pub fn new(probe: Arc<Probe>) -> Self {
  method poll_shutdown (line 196) | fn poll_shutdown(&self, _cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 212) | fn reinit(&self, iface: &Interface) {
  function dummy_packet_header (line 222) | pub fn dummy_packet_header() -> Route {

FILE: qinterface/tests/components.rs
  type RouterState (line 12) | struct RouterState {
  type RouterComponent (line 18) | struct RouterComponent {
  method poll_shutdown (line 23) | fn poll_shutdown(&self, _cx: &mut std::task::Context<'_>) -> std::task::...
  method reinit (line 28) | fn reinit(&self, _iface: &Interface) {
  type ClientState (line 34) | struct ClientState {
  type ClientComponent (line 40) | struct ClientComponent {
  method poll_shutdown (line 45) | fn poll_shutdown(&self, _cx: &mut std::task::Context<'_>) -> std::task::...
  method reinit (line 49) | fn reinit(&self, iface: &Interface) {
  function component_dependency_missing_then_added_is_observable_on_rebind (line 65) | fn component_dependency_missing_then_added_is_observable_on_rebind() {
  function component_dependency_present_is_visible_inside_reinit (line 96) | fn component_dependency_present_is_visible_inside_reinit() {

FILE: qinterface/tests/lifecycle.rs
  function unbind_destroys_and_weak_upgrade_fails (line 10) | fn unbind_destroys_and_weak_upgrade_fails() {
  function auto_drop_when_last_ref_gone_allows_rebind (line 53) | fn auto_drop_when_last_ref_gone_allows_rebind() {

FILE: qinterface/tests/locations.rs
  function locations_component_emits_closed_then_upsert_on_rebind (line 13) | fn locations_component_emits_closed_then_upsert_on_rebind() {

FILE: qinterface/tests/rebind.rs
  function manual_rebind_makes_old_interface_stale (line 9) | fn manual_rebind_makes_old_interface_stale() {

FILE: qmacro/src/derive.rs
  function quic_parameters (line 7) | pub fn quic_parameters(item: TokenStream) -> Result<TokenStream2, Error> {
  function parse_variant_attrs (line 101) | fn parse_variant_attrs(variant: &Variant) -> Result<ParamArgs, Error> {
  type ParamArgs (line 122) | struct ParamArgs {
    method gen_validate (line 131) | fn gen_validate(&self, id: &Ident) -> Result<TokenStream2, &'static st...
    method gen_default_value (line 164) | fn gen_default_value(&self) -> TokenStream2 {
    method gen_value_type (line 171) | fn gen_value_type(&self) -> TokenStream2 {
  type ParamType (line 178) | enum ParamType {
  method from_string (line 189) | fn from_string(lit: &str) -> ::darling::Result<Self> {
  method from_expr (line 202) | fn from_expr(expr: &Expr) -> darling::Result<Self> {

FILE: qmacro/src/lib.rs
  function quic_parameters (line 7) | pub fn quic_parameters(item: TokenStream) -> TokenStream {

FILE: qprotocol/src/stun/msg.rs
  constant BINDING_REQUEST (line 15) | pub const BINDING_REQUEST: u16 = 0x0001;
  constant BINDING_RESPONSE (line 16) | pub const BINDING_RESPONSE: u16 = 0x0101;
  type TransactionId (line 19) | pub struct TransactionId([u8; 16]);
    method as_ref (line 22) | fn as_ref(&self) -> &[u8] {
    method from_slice (line 28) | pub fn from_slice(slice: &[u8]) -> Self {
    method random (line 34) | pub fn random() -> Self {
  type Packet (line 42) | pub enum Packet {
  type Attr (line 49) | pub enum Attr {
    method typ (line 147) | pub fn typ(&self) -> AttrType {
    method be_attr (line 157) | fn be_attr(input: &[u8]) -> IResult<&[u8], Self> {
  type AttrType (line 64) | pub enum AttrType {
    type Error (line 97) | type Error = InvalidAttrType;
    method try_from (line 99) | fn try_from(value: u8) -> Result<Self, Self::Error> {
  type InvalidAttrType (line 78) | pub struct InvalidAttrType(u8);
  function from (line 81) | fn from(value: AttrType) -> Self {
  type WriteAttr (line 115) | trait WriteAttr {
    method put_attr (line 116) | fn put_attr(&mut self, attr: &Attr);
    method put_attr (line 120) | fn put_attr(&mut self, attr: &Attr) {
  type Request (line 188) | pub struct Request(Vec<Attr>);
    method change_ip_and_port (line 219) | pub fn change_ip_and_port() -> Self {
    method change_port (line 225) | pub fn change_port() -> Self {
    method add_response_address (line 231) | pub fn add_response_address(&mut self, addr: SocketAddr) -> &mut Self {
    method with_response_addr (line 237) | pub fn with_response_addr(addr: SocketAddr) -> Self {
    method change_request (line 241) | pub fn change_request(&self) -> Option<u8> {
    method response_address (line 250) | pub fn response_address(&self) -> Option<&SocketAddr> {
  method default (line 194) | fn default() -> Self {
  type WriteRequest (line 199) | pub(crate) trait WriteRequest {
    method put_request (line 200) | fn put_request(&mut self, request: &Request);
    method put_request (line 204) | fn put_request(&mut self, request: &Request) {
  function be_request (line 211) | pub fn be_request(input: &[u8]) -> IResult<&[u8], Request> {
  constant CHANGE_PORT (line 215) | pub const CHANGE_PORT: u8 = 0x01;
  constant CHANGE_IP (line 216) | pub const CHANGE_IP: u8 = 0x02;
  type Response (line 261) | pub struct Response(pub Vec<Attr>);
    method with (line 280) | pub fn with(attrs: Vec<Attr>) -> Self {
    method map_addr (line 284) | pub fn map_addr(&self) -> io::Result<SocketAddr> {
    method changed_addr (line 293) | pub fn changed_addr(&self) -> io::Result<SocketAddr> {
    method source_addr (line 302) | pub fn source_addr(&self) -> io::Result<SocketAddr> {
  type WriteResponse (line 263) | pub(crate) trait WriteResponse {
    method put_response (line 264) | fn put_response(&mut self, response: &Response);
    method put_response (line 268) | fn put_response(&mut self, response: &Response) {
  function be_response (line 275) | pub fn be_response(input: &[u8]) -> IResult<&[u8], Response> {
  function be_packet (line 312) | pub fn be_packet(input: &[u8]) -> IResult<&[u8], (TransactionId, Packet)> {
  type WritePacket (line 323) | pub trait WritePacket {
    method put_packet (line 324) | fn put_packet(&mut self, txid: &TransactionId, packet: &Packet);
    method put_packet (line 328) | fn put_packet(&mut self, txid: &TransactionId, packet: &Packet) {
  function attr_deserialize (line 349) | fn attr_deserialize() {
  function request_serialize (line 375) | fn request_serialize() {

FILE: qrecovery/src/crypto.rs
  type Sender (line 23) | pub(super) struct Sender {
    method try_load_data (line 34) | fn try_load_data<P>(&mut self, packet: &mut P) -> Result<(), Signals>
    method on_data_acked (line 52) | fn on_data_acked(&mut self, crypto_frame: &CryptoFrame) {
    method may_loss_data (line 61) | fn may_loss_data(&mut self, crypto_frame: &CryptoFrame) {
    method poll_write (line 68) | fn poll_write(&mut self, cx: &mut Context<'_>, buf: &[u8]) -> Poll<io:...
    method poll_flush (line 91) | fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
  type ArcSender (line 105) | pub(super) type ArcSender = Arc<Mutex<Sender>>;
  type CryptoStreamWriter (line 114) | pub struct CryptoStreamWriter(pub(super) ArcSender);
  type CryptoStreamOutgoing (line 117) | pub struct CryptoStreamOutgoing(pub(super) ArcSender);
    method try_load_data_into (line 140) | pub fn try_load_data_into<P>(&self, packet: &mut P, force: bool) -> Re...
    method package (line 163) | pub fn package(self, epoch: Epoch) -> CryptoStreamPackage {
    method on_data_acked (line 174) | pub fn on_data_acked(&self, crypto_frame: &CryptoFrame) {
    method may_loss_data (line 179) | pub fn may_loss_data(&self, crypto_frame: &CryptoFrame) {
  method poll_write (line 120) | fn poll_write(
  method poll_flush (line 128) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 132) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io...
  type CryptoStreamPackage (line 184) | pub struct CryptoStreamPackage {
    method dump (line 194) | fn dump(&mut self, packet: &mut P) -> Result<PacketContent, Signals> {
  function create (line 206) | pub(super) fn create(tx_wakers: ArcSendWakers) -> ArcSender {
  type Recver (line 235) | pub(super) struct Recver {
    method recv (line 241) | fn recv(&mut self, offset: u64, data: Bytes) {
    method poll_read (line 251) | fn poll_read<T: BufMut>(
  type ArcRecver (line 270) | pub(super) type ArcRecver = Arc<Mutex<Recver>>;
  type CryptoStreamReader (line 274) | pub struct CryptoStreamReader(pub(super) ArcRecver);
  type CryptoStreamIncoming (line 277) | pub struct CryptoStreamIncoming(pub(super) ArcRecver);
    type Output (line 290) | type Output = ();
    method recv_frame (line 292) | fn recv_frame(&self, (frame, data): (CryptoFrame, Bytes)) -> Result<Se...
  method poll_read (line 280) | fn poll_read(
  function create (line 298) | pub(super) fn create() -> ArcRecver {
  type CryptoStream (line 312) | pub struct CryptoStream {
    method new (line 319) | pub fn new(tx_wakers: ArcSendWakers) -> Self {
    method writer (line 327) | pub fn writer(&self) -> CryptoStreamWriter {
    method reader (line 332) | pub fn reader(&self) -> CryptoStreamReader {
    method outgoing (line 337) | pub fn outgoing(&self) -> CryptoStreamOutgoing {
    method incoming (line 342) | pub fn incoming(&self) -> CryptoStreamIncoming {
  function test_read (line 358) | async fn test_read() {

FILE: qrecovery/src/journal.rs
  type Journal (line 15) | pub struct Journal<T> {
  function with_capacity (line 22) | pub fn with_capacity(capacity: usize, max_ack_delay: Option<Duration>) -...
  function of_sent_packets (line 30) | pub fn of_sent_packets(&self) -> ArcSentJournal<T> {
  function of_rcvd_packets (line 35) | pub fn of_rcvd_packets(&self) -> ArcRcvdJournal {
  function as_ref (line 41) | fn as_ref(&self) -> &ArcSentJournal<T> {
  function as_ref (line 47) | fn as_ref(&self) -> &ArcRcvdJournal {

FILE: qrecovery/src/journal/rcvd.rs
  type State (line 22) | enum State {
    method track_packet_in_ack_frame (line 32) | fn track_packet_in_ack_frame(&mut self, pn: u64) -> bool {
    method could_expire (line 52) | fn could_expire(&self, now: Instant) -> bool {
  type RcvdJournal (line 68) | struct RcvdJournal {
    method with_capacity (line 76) | fn with_capacity(capacity: usize, max_ack_delay: Option<Duration>) -> ...
    method decode_pn (line 85) | fn decode_pn(&mut self, pkt_number: PacketNumber) -> Result<u64, Inval...
    method on_rcvd_pn (line 98) | fn on_rcvd_pn(&mut self, pn: u64, is_ack_eliciting: bool, pto: Duratio...
    method on_rcvd_ack (line 120) | fn on_rcvd_ack(&mut self, ack_frame: &AckFrame) {
    method rotate_queue (line 139) | fn rotate_queue(&mut self) {
    method gen_ack_frame_util (line 150) | fn gen_ack_frame_util(
    method need_ack (line 257) | fn need_ack(&self) -> Option<(u64, Instant)> {
  type ArcRcvdJournal (line 280) | pub struct ArcRcvdJournal {
    method with_capacity (line 289) | pub fn with_capacity(capacity: usize, max_ack_delay: Option<Duration>)...
    method decode_pn (line 314) | pub fn decode_pn(&self, encoded_pn: PacketNumber) -> Result<u64, Inval...
    method on_rcvd_pn (line 323) | pub fn on_rcvd_pn(&self, pn: u64, is_ack_eliciting: bool, pto: Duratio...
    method gen_ack_frame_util (line 335) | pub fn gen_ack_frame_util(
    method on_rcvd_ack (line 348) | pub fn on_rcvd_ack(&self, ack_frame: &AckFrame) {
    method need_ack (line 352) | pub fn need_ack(&self) -> Option<(u64, Instant)> {
    method revise_max_ack_delay (line 356) | pub fn revise_max_ack_delay(&self, max_ack_delay: Duration) {
    method ack_package (line 360) | pub fn ack_package<'r>(&'r self, need_ack: Option<(u64, Instant)>) -> ...
  type AckPackege (line 368) | pub struct AckPackege<'r> {
  function dump (line 378) | fn dump(&mut self, target: &mut Target) -> Result<PacketContent, Signals> {
  function test_rcvd_pkt_records (line 401) | fn test_rcvd_pkt_records() {
  function gen_ack_frame (line 448) | fn gen_ack_frame() {

FILE: qrecovery/src/journal/sent.rs
  type SentPktState (line 23) | enum SentPktState {
    method skipped (line 45) | fn skipped() -> Self {
    method new (line 49) | fn new(nframes: usize, sent_time: Instant, retran_time: Instant, expir...
    method nframes (line 58) | fn nframes(&self) -> usize {
    method be_acked (line 67) | fn be_acked(&mut self) -> usize {
    method maybe_lost (line 100) | fn maybe_lost(&mut self) -> usize {
    method should_retransmit_after (line 120) | fn should_retransmit_after(&mut self, now: &Instant) -> bool {
    method should_remain_after (line 139) | fn should_remain_after(&self, pn: u64, now: &Instant) -> bool {
  type SentJournal (line 161) | struct SentJournal<T> {
  function on_packet_acked (line 171) | fn on_packet_acked(&mut self, pn: u64) -> impl Iterator<Item = T> + '_ {
  function may_loss_packet (line 187) | fn may_loss_packet(&mut self, pn: u64) -> impl Iterator<Item = T> + '_ {
  function fast_retransmit (line 204) | fn fast_retransmit(&mut self) -> impl Iterator<Item = T> + '_ {
  function with_capacity (line 223) | fn with_capacity(capacity: usize) -> Self {
  function resize (line 231) | fn resize(&mut self) {
  type ArcSentJournal (line 261) | pub struct ArcSentJournal<T>(Arc<Mutex<SentJournal<T>>>);
  method clone (line 264) | fn clone(&self) -> Self {
  function with_capacity (line 274) | pub fn with_capacity(capacity: usize) -> Self {
  function rotate (line 279) | pub fn rotate(&self) -> SentRotateGuard<'_, T> {
  function new_packet (line 286) | pub fn new_packet(&self) -> NewPacketGuard<'_, T> {
  type SentRotateGuard (line 298) | pub struct SentRotateGuard<'a, T> {
  function update_largest (line 306) | pub fn update_largest(&mut self, ack_frame: &AckFrame) -> Result<(), Qui...
  function on_packet_acked (line 321) | pub fn on_packet_acked(&mut self, pn: u64) -> impl Iterator<Item = T> + ...
  function may_loss_packet (line 326) | pub fn may_loss_packet(&mut self, pn: u64) -> impl Iterator<Item = T> + ...
  function fast_retransmit (line 330) | pub fn fast_retransmit(&mut self) -> impl Iterator<Item = T> + '_ {
  method drop (line 336) | fn drop(&mut self) {
  type NewPacketGuard (line 355) | pub struct NewPacketGuard<'a, T> {
  function pn (line 367) | pub fn pn(&self) -> (u64, PacketNumber) {
  function record_trivial (line 376) | pub fn record_trivial(&mut self) {
  function record_frame (line 386) | pub fn record_frame(&mut self, frame: T) {
  function build_with_time (line 390) | pub fn build_with_time(mut self, retran_timeout: Duration, expire_timeou...
  function build_trivial (line 411) | pub fn build_trivial(mut self) {

FILE: qrecovery/src/recv/incoming.rs
  type Incoming (line 13) | pub struct Incoming<TX>(ArcRecver<TX>);
  function recv_data (line 29) | pub fn recv_data(
  function recv_reset (line 71) | pub fn recv_reset(&self, reset_frame: ResetStreamFrame) -> Result<usize,...
  function new (line 94) | pub fn new(recver: ArcRecver<TX>) -> Self {
  function on_conn_error (line 104) | pub fn on_conn_error(&self, err: &Error) {

FILE: qrecovery/src/recv/rcvbuf.rs
  type Segment (line 9) | struct Segment {
    method new_with_data (line 15) | fn new_with_data(offset: u64, data: Bytes) -> Self {
    method end (line 19) | fn end(&self) -> u64 {
  type RecvBuf (line 36) | pub struct RecvBuf {
    method is_empty (line 45) | pub fn is_empty(&self) -> bool {
    method nread (line 69) | pub fn nread(&self) -> u64 {
    method largest_offset (line 76) | pub fn largest_offset(&self) -> u64 {
    method recv (line 108) | pub fn recv(&mut self, offset: u64, mut data: Bytes) -> u64 {
    method available (line 221) | pub fn available(&self) -> u64 {
    method is_readable (line 236) | pub fn is_readable(&self) -> bool {
    method try_read (line 270) | pub fn try_read(&mut self, dst: &mut impl BufMut) -> usize {
    method try_next (line 293) | pub fn try_next(&mut self) -> Option<Bytes> {
  function test_no_overlap (line 309) | fn test_no_overlap() {
  function test_left_partially_overlap (line 326) | fn test_left_partially_overlap() {
  function test_right_partially_overlap (line 340) | fn test_right_partially_overlap() {
  function test_same_offset (line 355) | fn test_same_offset() {
  function test_fully_overlap_right (line 367) | fn test_fully_overlap_right() {
  function test_left_fully_overlap (line 382) | fn test_left_fully_overlap() {
  function test_right_fully_overlapp (line 393) | fn test_right_fully_overlapp() {
  function test_left_right_partially_overlap (line 407) | fn test_left_right_partially_overlap() {
  function test_left_right_fully_overlap (line 421) | fn test_left_right_fully_overlap() {
  function test_recvbuf_read (line 434) | fn test_recvbuf_read() {

FILE: qrecovery/src/recv/reader.rs
  type StopSending (line 20) | pub trait StopSending {
    method stop (line 34) | fn stop(&mut self, error_code: u64);
    method stop (line 204) | fn stop(&mut self, error_code: u64) {
  type Reader (line 87) | pub struct Reader<TX> {
  function new (line 98) | pub(crate) fn new(inner: ArcRecver<TX>) -> Self {
  function poll_read (line 107) | pub fn poll_read(
  function poll_next (line 149) | pub fn poll_next(
  method poll_read (line 229) | fn poll_read(
  type Item (line 242) | type Item = Result<Bytes, StreamError>;
  method poll_next (line 244) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  method drop (line 250) | fn drop(&mut self) {

FILE: qrecovery/src/recv/recver.rs
  type Recv (line 24) | pub(super) struct Recv<TX> {
  function poll_read (line 38) | pub(super) fn poll_read(&mut self, cx: &mut Context<'_>, buf: &mut impl ...
  function poll_next (line 73) | pub(super) fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Bytes> {
  function stop (line 110) | pub(super) fn stop(&mut self, err_code: u64) {
  function determin_size (line 122) | pub(super) fn determin_size(
  function new (line 164) | pub(super) fn new(stream_id: StreamId, buf_size: u64, broker: TX) -> Self {
  function stream_id (line 176) | pub(super) fn stream_id(&self) -> StreamId {
  function recv (line 180) | pub(super) fn recv(
  function recv_reset (line 222) | pub(super) fn recv_reset(
  function is_stopped (line 243) | pub(super) fn is_stopped(&self) -> bool {
  function wake_reader (line 247) | pub(super) fn wake_reader(&mut self) {
  type SizeKnown (line 258) | pub struct SizeKnown<TX> {
  function stream_id (line 268) | pub(super) fn stream_id(&self) -> StreamId {
  function recv (line 272) | pub(super) fn recv(
  function is_all_rcvd (line 321) | pub(super) fn is_all_rcvd(&self) -> bool {
  function read (line 326) | pub(super) fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
  function poll_read (line 336) | pub(super) fn poll_read(&mut self, cx: &mut Context<'_>, buf: &mut impl ...
  function poll_next (line 358) | pub(super) fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Bytes> {
  function recv_reset (line 377) | pub(super) fn recv_reset(&mut self, reset_frame: &ResetStreamFrame) -> R...
  function is_stopped (line 395) | pub(super) fn is_stopped(&self) -> bool {
  function wake_reader (line 399) | pub(super) fn wake_reader(&mut self) {
  function upgrade (line 410) | pub(super) fn upgrade(&mut self) -> DataRcvd {
  function stop (line 432) | pub(super) fn stop(&mut self, err_code: u64) {
  type DataRcvd (line 449) | pub struct DataRcvd {
    method read (line 458) | pub(super) fn read(&mut self, mut buf: &mut [u8]) -> io::Result<usize> {
    method poll_read (line 467) | pub(super) fn poll_read(&mut self, buf: &mut impl BufMut) {
    method poll_next (line 479) | pub(super) fn poll_next(&mut self) -> Option<Bytes> {
    method is_all_read (line 493) | pub(super) fn is_all_read(&self) -> bool {
    method upgrade (line 509) | pub(super) fn upgrade(&self) {
  function log_reset_event (line 498) | fn log_reset_event(stream_id: StreamId, old: GranularStreamStates) {
  type Recver (line 525) | pub(super) enum Recver<TX> {
  function new (line 535) | pub(super) fn new(stream_id: StreamId, buf_size: u64, frames_tx: TX) -> ...
  type ArcRecver (line 552) | pub struct ArcRecver<TX>(Arc<Mutex<Result<Recver<TX>, Error>>>);
  function new (line 559) | pub(crate) fn new(stream_id: StreamId, buf_size: u64, frames_tx: TX) -> ...
  function recver (line 567) | pub(super) fn recver(&'_ self) -> MutexGuard<'_, Result<Recver<TX>, Erro...

FILE: qrecovery/src/reliable.rs
  type ArcReliableFrameDeque (line 31) | pub struct ArcReliableFrameDeque<F> {
  method clone (line 37) | fn clone(&self) -> Self {
  function with_capacity_and_wakers (line 47) | pub fn with_capacity_and_wakers(capacity: usize, tx_wakers: ArcSendWaker...
  function frames_guard (line 54) | fn frames_guard(&self) -> MutexGuard<'_, VecDeque<F>> {
  function try_load_frames_into (line 59) | pub fn try_load_frames_into<P: ?Sized>(&self, packet: &mut P) -> Result<...
  function dump (line 79) | fn dump(&mut self, packet: &mut P) -> Result<PacketContent, Signals> {
  function send_frame (line 90) | fn send_frame<I: IntoIterator<Item = T>>(&self, iter: I) {

FILE: qrecovery/src/send/outgoing.rs
  type Outgoing (line 19) | pub struct Outgoing<TX>(ArcSender<TX>);
  function try_load_data_into (line 31) | pub fn try_load_data_into<P>(
  function new (line 96) | pub fn new(sender: ArcSender<TX>) -> Self {
  function update_window (line 105) | pub fn update_window(&self, max_stream_data: u64) {
  function on_data_acked (line 116) | pub fn on_data_acked(&self, frame: &StreamFrame) -> bool {
  function may_loss_data (line 151) | pub fn may_loss_data(&self, frame: &StreamFrame) {
  function revise_max_stream_data (line 171) | pub fn revise_max_stream_data(&self, zero_rtt_rejected: bool, max_stream...
  function be_stopped (line 194) | pub fn be_stopped(&self, error_code: u64) -> Option<u64> {
  function on_reset_acked (line 239) | pub fn on_reset_acked(&self, sid: StreamId) {
  function on_conn_error (line 264) | pub fn on_conn_error(&self, err: &QuicError) {

FILE: qrecovery/src/send/sender.rs
  function log_reset_event (line 26) | fn log_reset_event(sid: StreamId, from_state: GranularStreamStates) {
  type ReadySender (line 41) | pub struct ReadySender<TX> {
  function new (line 53) | pub(super) fn new(
  function stream_id (line 72) | pub(super) fn stream_id(&self) -> StreamId {
  function poll_ready (line 90) | pub(crate) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result...
  function write (line 103) | pub(crate) fn write(&mut self, data: Bytes) -> Result<(), StreamError> {
  function update_window (line 129) | pub(super) fn update_window(&mut self, max_stream_data: u64) {
  function revise_max_stream_data (line 143) | pub(super) fn revise_max_stream_data(&mut self, zero_rtt_rejected: bool,...
  function poll_flush (line 150) | pub(super) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function poll_shutdown (line 159) | pub(super) fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function wake_all (line 166) | pub(super) fn wake_all(&mut self) {
  function be_stopped (line 178) | pub(super) fn be_stopped(&mut self) -> u64 {
  function upgrade (line 188) | pub(super) fn upgrade(&mut self) -> SendingSender<TX> {
  function cancel (line 214) | pub(super) fn cancel(&mut self, err_code: u64) -> ResetStreamError {
  type SendingSender (line 233) | pub struct SendingSender<TX> {
  type StreamData (line 244) | pub type StreamData<'s> = (Range<u64>, bool, Vec<Bytes>, bool);
  function stream_id (line 247) | pub(super) fn stream_id(&self) -> StreamId {
  function poll_ready (line 251) | pub(super) fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result...
  function write (line 264) | pub(super) fn write(&mut self, data: Bytes) -> Result<(), StreamError> {
  function update_window (line 291) | pub(super) fn update_window(&mut self, max_stream_data: u64) {
  function pick_up (line 305) | pub(super) fn pick_up<P>(
  function on_data_acked (line 342) | pub(super) fn on_data_acked(&mut self, frame: &StreamFrame) {
  function may_loss_data (line 351) | pub(super) fn may_loss_data(&mut self, frame: &StreamFrame) {
  function revise_max_stream_data (line 356) | pub(super) fn revise_max_stream_data(&mut self, zero_rtt_rejected: bool,...
  function poll_flush (line 363) | pub(super) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function poll_shutdown (line 372) | pub(super) fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function total_size (line 378) | pub(super) fn total_size(&self) -> Option<u64> {
  function wake_all (line 386) | pub(super) fn wake_all(&mut self) {
  function be_stopped (line 399) | pub(super) fn be_stopped(&mut self) -> u64 {
  function upgrade (line 407) | pub(super) fn upgrade(&mut self) -> DataSentSender<TX> {
  function cancel (line 431) | pub(super) fn cancel(&mut self, err_code: u64) -> ResetStreamError {
  type FinState (line 450) | enum FinState {
  type DataSentSender (line 457) | pub struct DataSentSender<TX> {
  function stream_id (line 469) | pub(super) fn stream_id(&self) -> StreamId {
  function pick_up (line 473) | pub(super) fn pick_up<P>(
  function on_data_acked (line 507) | pub(super) fn on_data_acked(&mut self, frame: &StreamFrame) {
  function is_all_rcvd (line 522) | pub(super) fn is_all_rcvd(&self) -> bool {
  function may_loss_data (line 526) | pub(super) fn may_loss_data(&mut self, frame: &StreamFrame) {
  function revise_max_stream_data (line 534) | pub(super) fn revise_max_stream_data(&mut self, zero_rtt_rejected: bool,...
  function poll_flush (line 541) | pub(super) fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function poll_shutdown (line 547) | pub(super) fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  function wake_all (line 554) | pub(super) fn wake_all(&mut self) {
  function be_stopped (line 563) | pub(super) fn be_stopped(&mut self) -> u64 {
  function cancel (line 574) | pub(super) fn cancel(&mut self, err_code: u64) -> ResetStreamError {
  type Sender (line 593) | pub(super) enum Sender<TX> {
  function new (line 603) | pub fn new(
  type ArcSender (line 627) | pub struct ArcSender<TX>(Arc<Mutex<Result<Sender<TX>, Error>>>);
  function new (line 631) | pub(crate) fn new(
  function update_window (line 646) | pub(crate) fn update_window(&self, max_stream_data: u64) {
  function sender (line 655) | pub(super) fn sender(&self) -> MutexGuard<'_, Result<Sender<TX>, Error>> {
  type MockBroker (line 667) | struct MockBroker(Arc<Mutex<Vec<ResetStreamFrame>>>);
    method send_frame (line 670) | fn send_frame<I: IntoIterator<Item = ResetStreamFrame>>(&self, iter: I) {
  function create_test_sender (line 675) | fn create_test_sender() -> ArcSender<MockBroker> {
  function test_ready_sender_new (line 683) | fn test_ready_sender_new() {
  function test_ready_sender_write (line 697) | fn test_ready_sender_write() {
  function test_ready_sender_poll_write (line 714) | async fn test_ready_sender_poll_write() {
  function test_sender_state_transitions (line 732) | fn test_sender_state_transitions() {
  function test_arc_sender (line 750) | fn test_arc_sender() {
  function test_data_sent_sender (line 762) | fn test_data_sent_sender() {
  function test_data_sent_sender_polling (line 783) | async fn test_data_sent_sender_polling() {

FILE: qrecovery/src/send/sndbuf.rs
  type Color (line 13) | enum Color {
    method prefix (line 22) | fn prefix(&self) -> u64 {
  type State (line 33) | struct State(u64);
    constant PREFIX (line 37) | const PREFIX: u64 = 0b11 << 62;
    constant SUFFIX (line 38) | const SUFFIX: u64 = u64::MAX >> 2;
    method encode (line 40) | fn encode(pos: u64, color: Color) -> Self {
    method offset (line 44) | fn offset(&self) -> u64 {
    method color (line 48) | fn color(&self) -> Color {
    method set_color (line 58) | fn set_color(&mut self, value: Color) {
    method decode (line 62) | fn decode(&self) -> (u64, Color) {
  method fmt (line 68) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 74) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type BufMap (line 87) | struct BufMap(VecDeque<State>, u64);
    method size (line 90) | fn size(&self) -> u64 {
    method extend_to (line 95) | fn extend_to(&mut self, pos: u64) -> u64 {
    method sent (line 110) | fn sent(&self) -> u64 {
    method pick (line 119) | fn pick<P>(
    method ack_rcvd (line 208) | fn ack_rcvd(&mut self, range: &Range<u64>) {
    method shift (line 311) | fn shift(&mut self) -> u64 {
    method may_loss (line 326) | fn may_loss(&mut self, range: &Range<u64>) {
    method resend_flighting (line 461) | fn resend_flighting(&mut self) {
    method same_before (line 471) | fn same_before(&self, mut index: usize, color: Color) -> usize {
    method same_after (line 482) | fn same_after(&self, mut index: usize, color: Color) -> usize {
    method merge_after (line 493) | fn merge_after(&mut self, index: usize, color: Color) {
    method may_lost_from (line 501) | fn may_lost_from(&mut self, mut idx_start: usize, end: u64) {
  type SendBuf (line 580) | pub struct SendBuf {
    method with_capacity (line 591) | pub fn with_capacity(capacity: u64) -> Self {
    method write (line 604) | pub fn write(&mut self, data: Bytes) {
    method max_data (line 621) | pub fn max_data(&self) -> u64 {
    method forget_sent_state (line 631) | pub fn forget_sent_state(&mut self) {
    method extend (line 637) | pub fn extend(&mut self, max_data: u64) {
    method is_empty (line 644) | pub fn is_empty(&self) -> bool {
    method written (line 651) | pub fn written(&self) -> u64 {
    method sent (line 656) | pub fn sent(&self) -> u64 {
    method remaining_mut (line 663) | pub fn remaining_mut(&self) -> u64 {
    method has_remaining_mut (line 670) | pub fn has_remaining_mut(&self) -> bool {
    method pick_up (line 699) | pub fn pick_up<P>(&mut self, predicate: P, flow_limit: usize) -> Resul...
    method on_data_acked (line 735) | pub fn on_data_acked(&mut self, range: &Range<u64>) {
    method may_loss_data (line 763) | pub fn may_loss_data(&mut self, range: &Range<u64>) {
    method resend_flighting (line 767) | pub fn resend_flighting(&mut self) {
    method is_all_rcvd (line 772) | pub fn is_all_rcvd(&self) -> bool {
  type Data (line 679) | type Data<'s> = (Range<u64>, bool, Vec<Bytes>);
  function test_state (line 784) | fn test_state() {
  function test_bufmap_empty (line 802) | fn test_bufmap_empty() {
  function test_bufmap_extend_to (line 808) | fn test_bufmap_extend_to() {
  function test_bufmap_pick (line 827) | fn test_bufmap_pick() {
  function test_bufmap_sent (line 919) | fn test_bufmap_sent() {
  function test_bufmap_recved (line 932) | fn test_bufmap_recved() {
  function test_bufmap_invalid_recved (line 1041) | fn test_bufmap_invalid_recved() {
  function test_bufmap_recved_overflow (line 1063) | fn test_bufmap_recved_overflow() {
  function test_bufmap_recved_over_end (line 1079) | fn test_bufmap_recved_over_end() {
  function test_bufmap_lost (line 1088) | fn test_bufmap_lost() {
  function test_bufmap_ack_and_lost_all (line 1253) | fn test_bufmap_ack_and_lost_all() {
  function test_bufmap_ack_and_lost_all2 (line 1279) | fn test_bufmap_ack_and_lost_all2() {

FILE: qrecovery/src/send/writer.rs
  type CancelStream (line 15) | pub trait CancelStream {
    method cancel (line 29) | fn cancel(&mut self, err_code: u64);
    method cancel (line 115) | fn cancel(&mut self, err_code: u64) {
  type Writer (line 86) | pub struct Writer<TX> {
  function new (line 93) | pub(crate) fn new(inner: ArcSender<TX>) -> Self {
  function poll_ready (line 143) | pub fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), St...
  function write (line 163) | pub fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
  function poll_write (line 179) | pub fn poll_write(
  function poll_flush (line 205) | pub fn poll_flush(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), St...
  function poll_shutdown (line 222) | pub fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<Result<(),...
  method poll_write (line 240) | fn poll_write(
  method poll_flush (line 251) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 256) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  type Error (line 262) | type Error = StreamError;
  function poll_ready (line 265) | fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function start_send (line 270) | fn start_send(self: Pin<&mut Self>, item: Bytes) -> Result<(), Self::Err...
  function poll_flush (line 275) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  function poll_close (line 280) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method drop (line 286) | fn drop(&mut self) {

FILE: qrecovery/src/streams.rs
  type Ext (line 50) | pub struct Ext<T>(T);
  function send_frame (line 57) | fn send_frame<I: IntoIterator<Item = F>>(&self, iter: I) {
  type DataStreams (line 78) | pub struct DataStreams<TX>(Arc<raw::DataStreams<TX>>)
  function new (line 89) | pub fn new<LR, RR>(
  function open_bi (line 111) | pub fn open_bi<'a>(&'a self, params: &'a ArcParameters) -> OpenBiStream<...
  function open_uni (line 120) | pub fn open_uni<'a>(&'a self, params: &'a ArcParameters) -> OpenUniStrea...
  function accept_bi (line 129) | pub fn accept_bi<'a>(&'a self, params: &'a ArcParameters) -> AcceptBiStr...
  function accept_uni (line 135) | pub fn accept_uni(&self) -> AcceptUniStream<'_, Ext<TX>> {
  type Output (line 144) | type Output = usize;
  function recv_frame (line 146) | fn recv_frame(&self, frame: StreamCtlFrame) -> Result<Self::Output, Erro...
  type Output (line 155) | type Output = usize;
  function recv_frame (line 157) | fn recv_frame(&self, frame: (StreamFrame, Bytes)) -> Result<Self::Output...
  type OpenBiStream (line 171) | pub struct OpenBiStream<'d, TX>
  type Output (line 183) | type Output = Result<Option<(StreamId, (Reader<Ext<TX>>, Writer<Ext<TX>>...
  method poll (line 185) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type OpenUniStream (line 198) | pub struct OpenUniStream<'a, TX>
  type Output (line 210) | type Output = Result<Option<(StreamId, Writer<Ext<TX>>)>, Error>;
  method poll (line 212) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: qrecovery/src/streams/error.rs
  type StreamError (line 7) | pub enum StreamError {
  function from (line 17) | fn from(value: StreamError) -> Self {

FILE: qrecovery/src/streams/io.rs
  type IOState (line 19) | pub(super) struct IOState(Arc<AtomicU8>);
    constant SENDING (line 22) | const SENDING: u8 = 0x1;
    constant RECEIVING (line 23) | const RECEIVING: u8 = 0x2;
    method send_only (line 25) | pub fn send_only() -> Self {
    method receive_only (line 29) | pub fn receive_only() -> Self {
    method bidirection (line 33) | pub fn bidirection() -> Self {
    method is_terminated (line 37) | pub fn is_terminated(&self) -> bool {
    method shutdown_send (line 41) | pub fn shutdown_send(&self) {
    method shutdown_receive (line 45) | pub fn shutdown_receive(&self) {
  type Output (line 51) | pub(super) struct Output<TX> {
  function new (line 59) | fn new() -> Self {
  type ArcOutput (line 71) | pub(super) struct ArcOutput<TX>(Arc<Mutex<Result<Output<TX>, QuicError>>>);
  function new (line 74) | pub(super) fn new() -> Self {
  function streams (line 78) | pub(super) fn streams(&self) -> MutexGuard<'_, Result<Output<TX>, QuicEr...
  function guard (line 82) | pub(super) fn guard(&'_ self) -> Result<ArcOutputGuard<'_, TX>, QuicErro...
  type ArcOutputGuard (line 91) | pub(super) struct ArcOutputGuard<'a, TX>(MutexGuard<'a, Result<Output<TX...
  type Target (line 94) | type Target = Output<TX>;
  method deref (line 96) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 105) | fn deref_mut(&mut self) -> &mut Self::Target {
  function insert (line 114) | pub(super) fn insert(&mut self, sid: StreamId, outgoing: Outgoing<TX>, i...
  function revise_max_stream_data (line 118) | pub(super) fn revise_max_stream_data(
  function on_conn_error (line 138) | pub(super) fn on_conn_error(&mut self, error: &QuicError) {
  type ArcInput (line 151) | pub(super) struct ArcInput<TX>(
  method default (line 156) | fn default() -> Self {
  function streams (line 163) | pub(super) fn streams(
  function guard (line 169) | pub(super) fn guard(&self) -> Result<ArcInputGuard<'_, TX>, QuicError> {
  type ArcInputGuard (line 179) | pub(super) struct ArcInputGuard<'a, TX> {
  function insert (line 184) | pub(super) fn insert(&mut self, sid: StreamId, incoming: Incoming<TX>, i...
  function on_conn_error (line 191) | pub(super) fn on_conn_error(&mut self, error: &QuicError) {

FILE: qrecovery/src/streams/listener.rs
  type Listener (line 22) | struct Listener<TX> {
  function new (line 32) | fn new() -> Self {
  function push_bi_stream (line 41) | fn push_bi_stream(&mut self, sid: StreamId, stream: (ArcRecver<TX>, ArcS...
  function push_recv_stream (line 48) | fn push_recv_stream(&mut self, sid: StreamId, stream: ArcRecver<TX>) {
  function poll_accept_bi_stream (line 56) | fn poll_accept_bi_stream(
  function poll_accept_recv_stream (line 79) | fn poll_accept_recv_stream(
  type ArcListener (line 94) | pub struct ArcListener<TX>(Arc<Mutex<Result<Listener<TX>, QuicError>>>);
  function new (line 97) | pub(crate) fn new() -> Self {
  function guard (line 101) | pub(crate) fn guard(&self) -> Result<ListenerGuard<'_, TX>, QuicError> {
  function accept_bi_stream (line 109) | pub fn accept_bi_stream<'a>(&'a self, params: &'a ArcParameters) -> Acce...
  function accept_uni_stream (line 116) | pub fn accept_uni_stream(&self) -> AcceptUniStream<'_, TX> {
  function poll_accept_bi_stream (line 121) | pub fn poll_accept_bi_stream(
  function poll_accept_uni_stream (line 132) | pub fn poll_accept_uni_stream(
  type ListenerGuard (line 143) | pub(crate) struct ListenerGuard<'a, TX> {
  function push_bi_stream (line 151) | pub(crate) fn push_bi_stream(&mut self, sid: StreamId, stream: (ArcRecve...
  function push_uni_stream (line 158) | pub(crate) fn push_uni_stream(&mut self, sid: StreamId, stream: ArcRecve...
  function on_conn_error (line 165) | pub(crate) fn on_conn_error(&mut self, e: &QuicError) {
  type AcceptBiStream (line 188) | pub struct AcceptBiStream<'a, TX> {
  type Output (line 197) | type Output = Result<(StreamId, (Reader<TX>, Writer<TX>)), QuicError>;
  method poll (line 199) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type AcceptUniStream (line 211) | pub struct AcceptUniStream<'l, TX> {
  type Output (line 219) | type Output = Result<(StreamId, Reader<TX>), QuicError>;
  method poll (line 221) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: qrecovery/src/streams/raw.rs
  type DataStreams (line 114) | pub struct DataStreams<TX> {
  function wrapper_error (line 136) | fn wrapper_error(fty: FrameType) -> impl FnOnce(ExceedLimitError) -> Qui...
  function try_load_data_into_once (line 147) | fn try_load_data_into_once<P, FTX>(
  function package (line 263) | pub fn package(
  function try_load_data_into (line 312) | pub fn try_load_data_into<P, FTX>(
  function on_data_acked (line 339) | pub fn on_data_acked(&self, frame: StreamFrame) {
  function may_loss_data (line 370) | pub fn may_loss_data(&self, stream_frame: &StreamFrame) {
  function on_reset_acked (line 385) | pub fn on_reset_acked(&self, reset_frame: ResetStreamFrame) {
  function recv_data (line 405) | pub fn recv_data(
  function recv_stream_control (line 448) | pub fn recv_stream_control(
  function on_conn_error (line 568) | pub fn on_conn_error(&self, error: &Error) {
  type StreamFramePackages (line 588) | pub struct StreamFramePackages<TX> {
  function dump (line 601) | fn dump(&mut self, packet: &mut P) -> Result<PacketContent, Signals> {
  function new (line 612) | pub(super) fn new<LR, RR>(
  function revise_params (line 661) | pub fn revise_params<Role>(&self, zero_rtt_rejected: bool, remote_params...
  function poll_open_bi_stream (line 696) | pub(super) fn poll_open_bi_stream(
  function poll_open_uni_stream (line 735) | pub(super) fn poll_open_uni_stream(
  function accept_bi (line 767) | pub(super) fn accept_bi<'a>(
  function accept_uni (line 774) | pub(super) fn accept_uni(&self) -> AcceptUniStream<'_, Ext<TX>> {
  function try_accept_sid (line 778) | fn try_accept_sid(&self, sid: StreamId) -> Result<(), ExceedLimitError> {
  function try_accept_bi_sid (line 785) | fn try_accept_bi_sid(&self, sid: StreamId) -> Result<(), ExceedLimitErro...
  function try_accept_uni_sid (line 815) | fn try_accept_uni_sid(&self, sid: StreamId) -> Result<(), ExceedLimitErr...
  function create_sender (line 839) | fn create_sender(&self, sid: StreamId, buf_size: u64) -> ArcSender<Ext<T...
  function create_recver (line 849) | fn create_recver(&self, sid: StreamId, buf_size: u64) -> ArcRecver<Ext<T...

FILE: qresolve/src/lib.rs
  type PublishFuture (line 10) | pub type PublishFuture<'a> = BoxFuture<'a, io::Result<()>>;
  type Publish (line 12) | pub trait Publish: Display + Debug {
    method publish (line 13) | fn publish<'a>(&'a self, name: &'a str, packet: &'a [u8]) -> PublishFu...
  type Source (line 17) | pub enum Source {
  method fmt (line 25) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Record (line 35) | pub type Record = (Source, EndpointAddr);
  type RecordStream (line 36) | pub type RecordStream = BoxStream<'static, Record>;
  type ResolveResult (line 37) | pub type ResolveResult = io::Result<RecordStream>;
  type ResolveFuture (line 38) | pub type ResolveFuture<'r> = BoxFuture<'r, ResolveResult>;
  type Resolve (line 44) | pub trait Resolve: Send + Sync + Display + Debug {
    method lookup (line 45) | fn lookup<'l>(&'l self, name: &'l str) -> ResolveFuture<'l>;
    method lookup (line 61) | fn lookup<'l>(&'l self, name: &'l str) -> ResolveFuture<'l> {
  type SystemResolver (line 52) | pub struct SystemResolver;
  method fmt (line 55) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: qtraversal/examples/stun_client.rs
  type Arguments (line 15) | pub struct Arguments {
  function main (line 23) | async fn main() -> Result<()> {
  function init_logger (line 60) | fn init_logger() -> std::io::Result<()> {

FILE: qtraversal/examples/stun_server.rs
  type Arguments (line 15) | pub struct Arguments {
  function main (line 29) | async fn main() -> Result<()> {
  function init_logger (line 77) | fn init_logger(args: &Arguments) -> std::io::Result<()> {

FILE: qtraversal/src/addr.rs
  type AddressBook (line 16) | pub struct AddressBook {
    method add_local_address (line 27) | pub(crate) fn add_local_address(
    method add_local_endpoint (line 48) | pub(crate) fn add_local_endpoint(
    method add_peer_endpoint (line 59) | pub(crate) fn add_peer_endpoint(
    method remote_endpoint (line 73) | pub(crate) fn remote_endpoint(&self) -> &HashMap<EndpointAddr, Source> {
    method local_endpoint (line 77) | pub(crate) fn local_endpoint(&self) -> &HashSet<(BindUri, EndpointAddr...
    method remove_local_address (line 81) | pub(crate) fn remove_local_address(
    method get_local_address (line 100) | pub(crate) fn get_local_address(&self, seq_num: &u32) -> Option<(BindU...
    method add_remote_address (line 104) | pub(crate) fn add_remote_address(&mut self, remote: AddAddressFrame) -...
    method remove_remote_address (line 117) | pub(crate) fn remove_remote_address(&mut self, seq_num: u32) -> Option...
    method pick_local_address (line 121) | pub(crate) fn pick_local_address(

FILE: qtraversal/src/future.rs
  type FutureState (line 11) | enum FutureState<T> {
  method default (line 17) | fn default() -> Self {
  type ReadyFuture (line 23) | pub struct ReadyFuture<'f, T>(MutexGuard<'f, FutureState<T>>);
  type Target (line 26) | type Target = T;
  method deref (line 28) | fn deref(&self) -> &Self::Target {
  type Future (line 87) | pub struct Future<T> {
  function new (line 95) | pub fn new() -> Self {
  function with (line 107) | pub fn with(item: T) -> Self {
  function state (line 113) | fn state(&'_ self) -> MutexGuard<'_, FutureState<T>> {
  function assign (line 121) | pub fn assign(&self, item: T) -> Option<T> {
  function poll_get (line 136) | pub fn poll_get(&'_ self, cx: &mut Context<'_>) -> Poll<ReadyFuture<'_, ...
  function try_get (line 151) | pub fn try_get(&'_ self) -> Option<ReadyFuture<'_, T>> {
  function get (line 162) | pub async fn get(&'_ self) -> ReadyFuture<'_, T> {
  function clear (line 166) | pub fn clear(&self) {
  method default (line 176) | fn default() -> Self {
  function new (line 194) | fn new() {
  function wait (line 206) | async fn wait() {
  function change (line 232) | async fn change() {
  function multiple_wait (line 261) | async fn multiple_wait() {
  function clear (line 282) | async fn clear() {

FILE: qtraversal/src/lib.rs
  type PathWay (line 10) | pub type PathWay<E = EndpointAddr> = qbase::net::route::Pathway<E>;

FILE: qtraversal/src/nat/client.rs
  type ArcIoError (line 41) | pub struct ArcIoError(Arc<io::Error>);
    method fmt (line 44) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 50) | fn from(source: io::Error) -> Self {
  function from (line 56) | fn from(source: ArcIoError) -> io::Error {
  type ClientState (line 62) | enum ClientState {
  type ArcClientState (line 69) | struct ArcClientState {
    method new (line 75) | pub fn new() -> Self {
    method try_update (line 82) | pub fn try_update(&self, old_state: ClientState, new_state: ClientStat...
    method get (line 95) | pub fn get(&self) -> ClientState {
    method set (line 104) | pub fn set(&self, new_state: ClientState) -> ClientState {
    method wait (line 117) | pub fn wait(&self, expect: ClientState) -> impl futures::Future<Output...
  type StunClient (line 135) | pub struct StunClient<I: RefIO + 'static> {
  type ClientLocationData (line 149) | pub type ClientLocationData = Result<EndpointAddr, ArcIoError>;
  function new (line 152) | pub fn new(
  function lock_tasks (line 179) | fn lock_tasks(&self) -> MutexGuard<'_, JoinSet<()>> {
  function keep_alive_task (line 183) | fn keep_alive_task(&self) -> impl futures::Future<Output = ()> + use<I> {
  function poll_outer_addr (line 261) | pub fn poll_outer_addr(&self, cx: &mut Context) -> Poll<io::Result<Socke...
  function outer_addr (line 270) | pub async fn outer_addr(&self) -> io::Result<SocketAddr> {
  function agent_addr (line 274) | pub fn agent_addr(&self) -> SocketAddr {
  function get_outer_addr (line 278) | pub fn get_outer_addr(&self) -> Option<io::Result<SocketAddr>> {
  function nat_detect_task (line 288) | fn nat_detect_task(&self) -> impl futures::Future<Output = ()> + use<I> {
  function poll_nat_type (line 314) | pub fn poll_nat_type(&self, cx: &mut Context) -> Poll<io::Result<NatType...
  function nat_type (line 323) | pub async fn nat_type(&self) -> io::Result<NatType> {
  function get_nat_type (line 327) | pub fn get_nat_type(&self) -> Option<io::Result<NatType>> {
  function poll_close (line 346) | pub fn poll_close(&self, cx: &mut Context) -> Poll<()> {
  type StunClientComponent (line 359) | pub struct StunClientComponent {
    method new (line 364) | pub fn new(client: StunClient<WeakInterface>) -> Self {
    method lock_client (line 370) | fn lock_client(&self) -> MutexGuard<'_, StunClient<WeakInterface>> {
    method client (line 374) | pub fn client(&self) -> StunClient<WeakInterface> {
  method poll_shutdown (line 380) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 384) | fn reinit(&self, iface: &Interface) {
  type StunClientsMap (line 407) | type StunClientsMap<I> = HashMap<SocketAddr, StunClient<I>>;
  type StunClientsInner (line 410) | struct StunClientsInner<I: RefIO + 'static> {
  constant DEFAULT_STUN_SERVER (line 418) | pub const DEFAULT_STUN_SERVER: &str = "nat.genmeta.net:20004";
  constant MIN_AGENTS (line 421) | pub const MIN_AGENTS: usize = 3;
  function new (line 423) | pub fn new(
  function lock_clients (line 529) | fn lock_clients(&self) -> MutexGuard<'_, StunClientsMap<I>> {
  function poll_close (line 535) | pub fn poll_close(&mut self, cx: &mut Context<'_>) -> Poll<()> {
  type StunClients (line 551) | pub struct StunClients<I: RefIO + 'static> {
  function new (line 556) | pub fn new(
  function lock_clients (line 576) | fn lock_clients(&self) -> MutexGuard<'_, StunClientsInner<I>> {
  function with_clients (line 582) | pub fn with_clients<T>(&self, f: impl FnOnce(&StunClientsMap<I>) -> T) -...
  function poll_close (line 586) | pub fn poll_close(&self, cx: &mut Context<'_>) -> Poll<()> {
  type StunClientsComponent (line 591) | pub type StunClientsComponent = StunClients<WeakInterface>;
  method poll_shutdown (line 594) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 598) | fn reinit(&self, iface: &Interface) {
  function no_response_error (line 629) | fn no_response_error() -> io::Error {
  function detect_outer_addr (line 633) | async fn detect_outer_addr<I: RefIO>(
  constant RESTRICTED_RETRY_TIMES (line 660) | pub const RESTRICTED_RETRY_TIMES: u8 = 3;
  function detect_nat_type (line 662) | async fn detect_nat_type<I: RefIO>(

FILE: qtraversal/src/nat/iface.rs
  type StunIO (line 12) | pub trait StunIO: IO {
    method local_addr (line 13) | fn local_addr(&self) -> io::Result<SocketAddr> {
    method send_stun_packet (line 17) | fn send_stun_packet(

FILE: qtraversal/src/nat/msg.rs
  constant BINDING_REQUEST (line 15) | pub const BINDING_REQUEST: u16 = 0x0001;
  constant BINDING_RESPONSE (line 16) | pub const BINDING_RESPONSE: u16 = 0x0101;
  type TransactionId (line 19) | pub struct TransactionId([u8; 16]);
    method as_ref (line 22) | fn as_ref(&self) -> &[u8] {
    method from_slice (line 28) | pub fn from_slice(slice: &[u8]) -> Self {
    method random (line 34) | pub fn random() -> Self {
  type Packet (line 42) | pub enum Packet {
  type Attr (line 49) | pub enum Attr {
    method typ (line 147) | pub fn typ(&self) -> AttrType {
    method be_attr (line 157) | fn be_attr(input: &[u8]) -> IResult<&[u8], Self> {
  type AttrType (line 64) | pub enum AttrType {
    type Error (line 97) | type Error = InvalidAttrType;
    method try_from (line 99) | fn try_from(value: u8) -> Result<Self, Self::Error> {
  type InvalidAttrType (line 78) | pub struct InvalidAttrType(u8);
  function from (line 81) | fn from(value: AttrType) -> Self {
  type WriteAttr (line 115) | trait WriteAttr {
    method put_attr (line 116) | fn put_attr(&mut self, attr: &Attr);
    method put_attr (line 120) | fn put_attr(&mut self, attr: &Attr) {
  type Request (line 188) | pub struct Request(Vec<Attr>);
    method change_ip_and_port (line 219) | pub fn change_ip_and_port() -> Self {
    method change_port (line 225) | pub fn change_port() -> Self {
    method add_response_address (line 231) | pub fn add_response_address(&mut self, addr: SocketAddr) -> &mut Self {
    method with_response_addr (line 237) | pub fn with_response_addr(addr: SocketAddr) -> Self {
    method change_request (line 241) | pub fn change_request(&self) -> Option<u8> {
    method response_address (line 250) | pub fn response_address(&self) -> Option<&SocketAddr> {
  method default (line 194) | fn default() -> Self {
  type WriteRequest (line 199) | pub(crate) trait WriteRequest {
    method put_request (line 200) | fn put_request(&mut self, request: &Request);
    method put_request (line 204) | fn put_request(&mut self, request: &Request) {
  function be_request (line 211) | pub fn be_request(input: &[u8]) -> IResult<&[u8], Request> {
  constant CHANGE_PORT (line 215) | pub const CHANGE_PORT: u8 = 0x01;
  constant CHANGE_IP (line 216) | pub const CHANGE_IP: u8 = 0x02;
  type Response (line 261) | pub struct Response(pub Vec<Attr>);
    method with (line 280) | pub fn with(attrs: Vec<Attr>) -> Self {
    method map_addr (line 284) | pub fn map_addr(&self) -> io::Result<SocketAddr> {
    method changed_addr (line 293) | pub fn changed_addr(&self) -> io::Result<SocketAddr> {
    method source_addr (line 302) | pub fn source_addr(&self) -> io::Result<SocketAddr> {
  type WriteResponse (line 263) | pub(crate) trait WriteResponse {
    method put_response (line 264) | fn put_response(&mut self, response: &Response);
    method put_response (line 268) | fn put_response(&mut self, response: &Response) {
  function be_response (line 275) | pub fn be_response(input: &[u8]) -> IResult<&[u8], Response> {
  function be_packet (line 312) | pub fn be_packet(input: &[u8]) -> IResult<&[u8], (TransactionId, Packet)> {
  type WritePacket (line 323) | pub trait WritePacket {
    method put_packet (line 324) | fn put_packet(&mut self, txid: &TransactionId, packet: &Packet);
    method put_packet (line 328) | fn put_packet(&mut self, txid: &TransactionId, packet: &Packet) {
  function attr_deserialize (line 349) | fn attr_deserialize() {
  function request_serialize (line 375) | fn request_serialize() {

FILE: qtraversal/src/nat/router.rs
  type ResponseRouter (line 15) | type ResponseRouter = Arc<DashMap<TransactionId, Arc<SetOnce<(Response, ...
  type StunRouter (line 18) | pub struct StunRouter {
    method new (line 24) | pub fn new() -> Self {
    method deliver_stun_packet (line 28) | pub fn deliver_stun_packet(&self, txid: TransactionId, packet: Packet,...
    method receive_request (line 47) | pub async fn receive_request(&self) -> Option<(Request, TransactionId,...
    method close (line 54) | pub fn close(&self) {
    method register (line 59) | pub(super) fn register(
    method remove (line 67) | pub(super) fn remove(&self, transaction_id: &TransactionId) {
  type StunRouterComponentInner (line 73) | struct StunRouterComponentInner {
  type StunRouterComponent (line 79) | pub struct StunRouterComponent {
    method new (line 84) | pub fn new(ref_iface: WeakInterface) -> Self {
    method lock_inner (line 93) | fn lock_inner(&self) -> MutexGuard<'_, StunRouterComponentInner> {
    method ref_iface (line 97) | pub fn ref_iface(&self) -> WeakInterface {
    method router (line 101) | pub fn router(&self) -> StunRouter {
  method reinit (line 107) | fn reinit(&self, iface: &Interface) {
  method poll_shutdown (line 120) | fn poll_shutdown(&self, _cx: &mut Context<'_>) -> Poll<()> {

FILE: qtraversal/src/nat/server.rs
  type StunServerConfig (line 24) | pub struct StunServerConfig {
    method new (line 32) | pub fn new(change_port: Option<u16>, change_address: Option<SocketAddr...
  type StunServer (line 41) | pub struct StunServer<I: RefIO + 'static> {
  function new (line 48) | pub fn new(ref_iface: I, stun_router: StunRouter, config: StunServerConf...
  function spawn (line 63) | pub fn spawn(self) -> AbortOnDropHandle<io::Result<()>> {
  function serve_loop (line 70) | async fn serve_loop<I: RefIO>(
  function select_change_target (line 133) | fn select_change_target(
  type StunServerComponentInner (line 169) | struct StunServerComponentInner {
  type StunServerComponent (line 176) | pub struct StunServerComponent {
    method new (line 181) | pub fn new(
    method lock_inner (line 197) | fn lock_inner(&self) -> std::sync::MutexGuard<'_, StunServerComponentI...
  method poll_shutdown (line 203) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 213) | fn reinit(&self, iface: &Interface) {

FILE: qtraversal/src/nat/tx.rs
  type Transaction (line 13) | pub struct Transaction<I> {
  function begin (line 23) | pub fn begin(
  function send_request (line 41) | pub async fn send_request(
  function do_tick (line 56) | async fn do_tick(&self, dst: SocketAddr, request: Request) -> io::Result...
  method drop (line 67) | fn drop(&mut self) {

FILE: qtraversal/src/packet.rs
  constant STUN_HEADER_MASK (line 9) | const STUN_HEADER_MASK: u8 = 0b1111_1110;
  constant STUN_HEADER_BITS (line 10) | const STUN_HEADER_BITS: u8 = 0b1100_0010;
  constant FORWARD_HEADER_MASK (line 12) | const FORWARD_HEADER_MASK: u8 = 0b1110_0000;
  constant FORWARD_VERSION_MASK (line 13) | const FORWARD_VERSION_MASK: u8 = 0b1111_0000;
  constant FORWARD_HEADER_BITS (line 14) | const FORWARD_HEADER_BITS: u8 = 0b0110_0000;
  constant FORWARD_BIT (line 15) | const FORWARD_BIT: u8 = 0b0000_1000;
  constant FORWARD_FAMILY_BIT (line 16) | const FORWARD_FAMILY_BIT: u8 = 0b0000_0100;
  constant FORWARD_SRC_TYPE_BIT (line 17) | const FORWARD_SRC_TYPE_BIT: u8 = 0b0000_0010;
  constant FORWARD_DST_TYPE_BIT (line 18) | const FORWARD_DST_TYPE_BIT: u8 = 0b0000_0001;
  type HeaderType (line 21) | pub enum HeaderType {
  type StunHeader (line 37) | pub struct StunHeader {
    method new (line 42) | pub fn new(version: u16) -> Self {
    method encoding_size (line 46) | pub fn encoding_size() -> usize {
  function be_stun_header (line 51) | pub fn be_stun_header(input: &[u8]) -> nom::IResult<&[u8], StunHeader> {
  type WriteStunHeader (line 56) | pub trait WriteStunHeader {
    method put_stun_header (line 57) | fn put_stun_header(&mut self, stun_header: &StunHeader);
    method put_stun_header (line 61) | fn put_stun_header(&mut self, stun_header: &StunHeader) {
  type ForwardHeader (line 85) | pub struct ForwardHeader {
    method encoding_size (line 92) | pub fn encoding_size(pathway: &PathWay) -> usize {
    method pathway (line 99) | pub fn pathway(&self) -> PathWay {
    method new (line 103) | pub fn new(version: u8, pathway: &PathWay, buffer: &[u8]) -> Self {
  type WriteForwardHeader (line 113) | pub trait WriteForwardHeader {
    method put_forward_header (line 114) | fn put_forward_header(&mut self, forward_header: &ForwardHeader);
    method put_forward_header (line 118) | fn put_forward_header(&mut self, forward_header: &ForwardHeader) {
  function be_forward_header (line 137) | pub fn be_forward_header(input: &[u8]) -> nom::IResult<&[u8], ForwardHea...
  type Header (line 162) | pub enum Header {
  function be_header_type (line 167) | pub fn be_header_type(input: &[u8]) -> nom::IResult<&[u8], HeaderType> {
  function be_header (line 185) | pub fn be_header(input: &[u8]) -> nom::IResult<&[u8], Header> {
  type WriteHeader (line 199) | pub trait WriteHeader {
    method put_header (line 200) | fn put_header(&mut self, header: &Header);
    method put_header (line 204) | fn put_header(&mut self, header: &Header) {
  function test_stun_header (line 223) | fn test_stun_header() {

FILE: qtraversal/src/punch/predictor.rs
  constant MAX_CONCURRENT_SOCKETS (line 28) | const MAX_CONCURRENT_SOCKETS: usize = 60;
  constant MIN_PORT (line 29) | const MIN_PORT: u16 = 1024;
  constant PACKET_TTL (line 30) | const PACKET_TTL: u8 = 64;
  constant FIRST_PROBE_ID (line 31) | const FIRST_PROBE_ID: u32 = 1;
  constant MAX_PROBES (line 32) | const MAX_PROBES: u32 = 300;
  constant PACING_INTERVAL (line 33) | const PACING_INTERVAL: Duration = Duration::from_millis(20);
  type PortPredictor (line 35) | pub struct PortPredictor {
    method new (line 139) | pub fn new(
    method release_quota (line 171) | fn release_quota(&mut self, count: u32) -> io::Result<()> {
    method port_to_bind_uri (line 180) | fn port_to_bind_uri(&self, port: u16) -> BindUri {
    method release_interface (line 203) | async fn release_interface(&mut self, bind_uri: BindUri) {
    method release_probe (line 210) | async fn release_probe(&mut self, probe_id: u32) -> bool {
    method check_and_claim (line 218) | fn check_and_claim(&mut self, tx: &Transaction) -> Option<(BindUri, In...
    method evict_if_needed (line 225) | async fn evict_if_needed(
    method claim_probe (line 242) | fn claim_probe(&mut self, probe_id: u32) -> Option<(BindUri, Interface...
    method finalize (line 247) | async fn finalize(
    method predict (line 257) | pub(super) async fn predict(
    method create_and_send_probe (line 310) | async fn create_and_send_probe(
    method create_interface (line 359) | async fn create_interface(&mut self) -> io::Result<(BindUri, Interface...
    method release_all (line 399) | async fn release_all(&mut self) -> io::Result<()> {
    method acquire_quota (line 415) | async fn acquire_quota(&mut self, count: u32) -> io::Result<u32> {
  type PendingProbe (line 48) | struct PendingProbe {
  type PacketSendFn (line 54) | pub type PacketSendFn = Arc<
  type ProbeTable (line 66) | struct ProbeTable {
    method new (line 74) | fn new() -> Self {
    method len (line 83) | fn len(&self) -> usize {
    method contains_port (line 87) | fn contains_port(&self, port: u16) -> bool {
    method allocate_probe_id (line 91) | fn allocate_probe_id(&mut self) -> u32 {
    method insert (line 100) | fn insert(&mut self, probe_id: u32, bind_uri: BindUri, iface: Interfac...
    method take (line 113) | fn take(&mut self, probe_id: u32) -> Option<PendingProbe> {
    method oldest_probe_id (line 120) | fn oldest_probe_id(&self) -> Option<u32> {
    method pending_probe_ids (line 124) | fn pending_probe_ids(&self) -> Vec<u32> {
    method drain_bind_uris (line 128) | fn drain_bind_uris(&mut self) -> Vec<BindUri> {
  method drop (line 436) | fn drop(&mut self) {

FILE: qtraversal/src/punch/puncher.rs
  type StunClient (line 52) | type StunClient<I = WeakInterface> = crate::nat::client::StunClient<I>;
  constant HELLO_TTL (line 56) | const HELLO_TTL: u8 = 64;
  constant DEFAULT_PROBE_ID (line 57) | const DEFAULT_PROBE_ID: u32 = 0;
  constant KNOCK_TTL (line 59) | pub const KNOCK_TTL: u8 = 1;
  constant KNOCK_TTL (line 61) | pub const KNOCK_TTL: u8 = 5;
  constant KNOCK_TIMEOUT (line 64) | const KNOCK_TIMEOUT: Duration = Duration::from_millis(100);
  constant PUNCH_TIMEOUT (line 65) | const PUNCH_TIMEOUT: Duration = Duration::from_secs(3);
  constant PUNCH_ME_NOW_TIMEOUT (line 66) | const PUNCH_ME_NOW_TIMEOUT: Duration = Duration::from_secs(1);
  constant COLLISION_TIMEOUT (line 67) | const COLLISION_TIMEOUT: Duration = Duration::from_secs(3);
  constant BIRTHDAY_TIMEOUT (line 69) | const BIRTHDAY_TIMEOUT: Duration = Duration::from_secs(8);
  constant MAX_RETRIES (line 72) | const MAX_RETRIES: usize = 5;
  constant COLLISION_PORTS (line 73) | const COLLISION_PORTS: u32 = 800;
  type ArcPuncher (line 75) | pub struct ArcPuncher<TX, PH, S>(Arc<Puncher<TX, PH, S>>);
  method clone (line 78) | fn clone(&self) -> Self {
  function new (line 89) | pub fn new(
  type Puncher (line 110) | pub struct Puncher<TX, PH, S> {
  function new (line 130) | pub fn new(
  function send_packet (line 154) | pub async fn send_packet<P>(
  function collision (line 183) | async fn collision(
  method drop (line 214) | fn drop(&mut self) {
  function add_local_address (line 247) | pub fn add_local_address(
  function add_local_endpoint (line 300) | pub fn add_local_endpoint(
  function add_peer_endpoint (line 316) | pub fn add_peer_endpoint(
  function remove_local_address (line 332) | pub fn remove_local_address(&self, addr: SocketAddr) -> io::Result<()> {
  function recv_remove_address_frame (line 341) | fn recv_remove_address_frame(&self, remove_address_frame: RemoveAddressF...
  function recv_add_address_frame (line 346) | fn recv_add_address_frame(&self, add_address_frame: AddAddressFrame) -> ...
  function recv_punch_me_now (line 392) | fn recv_punch_me_now(
  function punch_actively (line 455) | async fn punch_actively(
  function punch_passively (line 850) | async fn punch_passively(
  function resolve_punch_connection (line 1052) | fn resolve_punch_connection(
  function extract_addresses (line 1087) | fn extract_addresses(
  type Output (line 1129) | type Output = ();
  function recv_frame (line 1131) | fn recv_frame(
  type Output (line 1176) | type Output = ();
  function recv_frame (line 1178) | fn recv_frame(
  function dynamic_iface (line 1202) | async fn dynamic_iface(

FILE: qtraversal/src/punch/scheduler.rs
  constant MAX_SOCKETS_PER_DEVICE (line 16) | const MAX_SOCKETS_PER_DEVICE: u32 = 300;
  constant MAX_PORTS_PER_DEVICE (line 17) | const MAX_PORTS_PER_DEVICE: u32 = 600;
  constant MAX_TOTAL_SOCKETS (line 18) | const MAX_TOTAL_SOCKETS: u32 = 600;
  constant MAX_TOTAL_PORTS (line 19) | const MAX_TOTAL_PORTS: u32 = 1200;
  constant PORT_COOLING_INTERVAL (line 20) | const PORT_COOLING_INTERVAL: Duration = Duration::from_secs(60);
  type Scheduler (line 22) | pub struct Scheduler {
    method new (line 31) | fn new() -> Self {
    method reap_cooling (line 41) | fn reap_cooling(&mut self) {
    method global_available (line 53) | fn global_available(&self) -> u32 {
    method poll_allocate (line 59) | pub fn poll_allocate(
    method release_port (line 100) | pub fn release_port(&mut self, count: u32, dst: SocketAddr, device: St...
  type DeviceKey (line 143) | struct DeviceKey {
    method new (line 149) | fn new(device: String, family: Family) -> Self {
  type DeviceLedger (line 154) | struct DeviceLedger {
    method new (line 162) | fn new() -> Self {
    method reap_cooling (line 171) | fn reap_cooling(&mut self) {
    method available (line 183) | fn available(&self) -> u32 {
  function test_addr (line 198) | fn test_addr() -> SocketAddr {
  function test_cx (line 202) | fn test_cx() -> Context<'static> {
  function test_scheduler_new (line 207) | fn test_scheduler_new() {
  function test_allocation_success (line 216) | fn test_allocation_success() {
  function test_allocation_pending (line 235) | fn test_allocation_pending() {
  function test_release_port (line 249) | fn test_release_port() {
  function test_global_limits (line 267) | fn test_global_limits() {
  function test_device_limits (line 289) | fn test_device_limits() {
  function test_global_not_updated_on_device_pending (line 305) | fn test_global_not_updated_on_device_pending() {
  function test_mutex_protection (line 327) | fn test_mutex_protection() {

FILE: qtraversal/src/punch/tx.rs
  type PunchId (line 10) | pub(crate) struct PunchId {
    method new (line 16) | pub fn new(local_seq: u32, remote_seq: u32) -> Self {
    method flip (line 23) | pub fn flip(self) -> Self {
    method fmt (line 32) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type AsPunchId (line 37) | pub(crate) trait AsPunchId {
    method punch_id (line 38) | fn punch_id(&self) -> PunchId;
    method punch_id (line 42) | fn punch_id(&self) -> PunchId {
    method punch_id (line 48) | fn punch_id(&self) -> PunchId {
    method punch_id (line 54) | fn punch_id(&self) -> PunchId {
    method punch_id (line 60) | fn punch_id(&self) -> PunchId {
  type Transaction (line 65) | pub(crate) struct Transaction {
    method new (line 72) | pub fn new() -> Self {
    method wait_punch_done (line 80) | pub async fn wait_punch_done(&self) -> (Link, PunchDoneFrame) {
    method try_punch_done (line 84) | pub fn try_punch_done(&self) -> Option<(Link, PunchDoneFrame)> {
    method wait_punch_hello (line 88) | pub async fn wait_punch_hello(&self) -> (Link, PunchHelloFrame) {
    method wait_punch_me_now (line 92) | pub async fn wait_punch_me_now(&self) -> PunchMeNowFrame {
    method store_punch_me_now (line 96) | pub fn store_punch_me_now(&self, frame: PunchMeNowFrame) {
    type Output (line 102) | type Output = ();
    method recv_frame (line 104) | fn recv_frame(
    type Output (line 114) | type Output = ();
    method recv_frame (line 116) | fn recv_frame(
    type Output (line 126) | type Output = ();
    method recv_frame (line 128) | fn recv_frame(

FILE: qtraversal/src/route.rs
  type ArcRecvQueue (line 33) | pub type ArcRecvQueue = ArcAsyncDeque<(BytesMut, PathWay, Link)>;
  type Forwarder (line 45) | pub enum Forwarder<I: RefIO + 'static> {
  function outers (line 51) | pub fn outers(&self) -> SmallVec<[SocketAddr; 8]> {
  function should_forward (line 63) | pub fn should_forward(&self, dst: EndpointAddr) -> Option<SocketAddr> {
  type ForwardersComponent (line 93) | pub struct ForwardersComponent {
    method new (line 98) | pub fn new(forwarder: Forwarder<WeakInterface>) -> Self {
    method new_client (line 104) | pub fn new_client(stun_clients: StunClients<WeakInterface>) -> Self {
    method new_server (line 108) | pub fn new_server(outer_addr: SocketAddr) -> Self {
    method lock_forwarders (line 112) | fn lock_forwarders(&self) -> MutexGuard<'_, Forwarder<WeakInterface>> {
    method forwarder (line 116) | pub fn forwarder(&self) -> Forwarder<WeakInterface> {
  method poll_shutdown (line 122) | fn poll_shutdown(&self, _cx: &mut Context<'_>) -> Poll<()> {
  method reinit (line 126) | fn reinit(&self, iface: &Interface) {
  type ReceiveAndDeliverPacket (line 137) | pub struct ReceiveAndDeliverPacket {
    method new (line 149) | pub fn new(
    method task (line 174) | pub fn task<I: RefIO + 'static>(
    method lock_task (line 262) | fn lock_task(&self) -> MutexGuard<'_, Option<AbortOnDropHandle<io::Res...
    method reinit (line 266) | pub fn reinit(&self, iface: &Interface) {
  type ReceiveAndDeliverPacketComponent (line 144) | pub type ReceiveAndDeliverPacketComponent = ReceiveAndDeliverPacket;
  method poll_shutdown (line 292) | fn poll_shutdown(&self, cx: &mut Context<'_>) -> std::task::Poll<()> {
  method reinit (line 302) | fn reinit(&self, iface: &Interface) {

FILE: qtraversal/tests/detect.rs
  type TestCase (line 18) | pub struct TestCase {
  constant STUN_AGENT (line 24) | pub const STUN_AGENT: &str = "10.10.0.64:20002";
  constant CASES (line 26) | pub const CASES: [TestCase; 10] = [
  function init_tracing (line 79) | pub fn init_tracing() -> io::Result<()> {
  function run (line 107) | fn run<F: Future<Output: Send + 'static> + Send + 'static>(
  function test_detect_case (line 121) | async fn test_detect_case(case: usize) {

FILE: qudp/examples/receive.rs
  type Args (line 6) | struct Args {
  function main (line 12) | async fn main() {

FILE: qudp/examples/send.rs
  type Args (line 9) | struct Args {
  function main (line 24) | async fn main() {

FILE: qudp/src/lib.rs
  constant BATCH_SIZE (line 14) | pub const BATCH_SIZE: usize = 64;
  type UdpSocket (line 28) | pub struct UdpSocket {
    method bind (line 34) | pub fn bind(addr: SocketAddr) -> io::Result<Self> {
    method local_addr (line 52) | pub fn local_addr(&self) -> io::Result<SocketAddr> {
    method poll_send_ready (line 56) | pub fn poll_send_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result...
    method poll_recv_ready (line 60) | pub fn poll_recv_ready(&self, cx: &mut Context<'_>) -> Poll<io::Result...
    method poll_send (line 64) | pub fn poll_send(
    method poll_recv (line 84) | pub fn poll_recv(
    method bind_device (line 103) | pub fn bind_device(&self, _device: &str) -> io::Result<()> {
    method send (line 148) | pub fn send<'a>(&'a self, iovecs: &'a [IoSlice<'a>], line: Line) -> Se...
    method receiver (line 156) | pub fn receiver(&self) -> Receiver<'_> {
  type Io (line 137) | pub trait Io {
    method config (line 138) | fn config(io: &socket2::Socket, addr: SocketAddr) -> io::Result<()>;
    method sendmsg (line 140) | fn sendmsg(&self, bufs: &[IoSlice<'_>], line: &Line) -> io::Result<usi...
    method recvmsg (line 142) | fn recvmsg(&self, bufs: &mut [IoSliceMut<'_>], line: &mut [Line]) -> i...
    method set_ttl (line 144) | fn set_ttl(&self, ttl: i32) -> io::Result<()>;
  type Send (line 171) | pub struct Send<'a> {
  type Output (line 178) | type Output = io::Result<usize>;
  method poll (line 180) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
  type Receiver (line 186) | pub struct Receiver<'u> {
  function poll_recv (line 194) | pub fn poll_recv(&mut self, cx: &mut Context) -> Poll<io::Result<usize>> {
  function recv (line 205) | pub async fn recv(&mut self) -> io::Result<usize> {

FILE: qudp/src/unix.rs
  constant OPTION_ON (line 19) | const OPTION_ON: bool = true;
  constant OPTION_OFF (line 20) | const OPTION_OFF: bool = false;
  method config (line 23) | fn config(socket: &Socket, addr: SocketAddr) -> io::Result<()> {
  method sendmsg (line 59) | fn sendmsg(&self, buffers: &[IoSlice<'_>], line: &Line) -> io::Result<us...
  method sendmsg (line 120) | fn sendmsg(&self, slices: &[IoSlice<'_>], send_line: &Line) -> io::Resul...
  method recvmsg (line 164) | fn recvmsg(
  method recvmsg (line 228) | fn recvmsg(
  method set_ttl (line 264) | fn set_ttl(&self, ttl: i32) -> io::Result<()> {
  function parse_cmsg (line 301) | fn parse_cmsg(cmsg: ControlMessageOwned, line: &mut Line) {
  type ToSocketAddr (line 315) | trait ToSocketAddr {
    method to_socketaddr (line 316) | fn to_socketaddr(&self) -> SocketAddr;
    method to_socketaddr (line 320) | fn to_socketaddr(&self) -> SocketAddr {

FILE: qudp/src/windows.rs
  constant CMSG_LEN (line 16) | const CMSG_LEN: usize = 128;
  type Aligned (line 19) | pub(crate) struct Aligned<T>(pub(crate) T);
  method config (line 22) | fn config(socket: &Socket, addr: SocketAddr) -> std::io::Result<()> {
  method sendmsg (line 60) | fn sendmsg(&self, bufs: &[std::io::IoSlice<'_>], line: &Line) -> std::io...
  method recvmsg (line 185) | fn recvmsg(
  method set_ttl (line 275) | fn set_ttl(&self, ttl: i32) -> io::Result<()> {
  function append_cmsg (line 299) | fn append_cmsg<'a, V: Copy>(
  function cmsg_decode (line 319) | fn cmsg_decode<T: Copy>(cmsg: &mut WinSock::CMSGHDR) -> T {
  function cmsghdr_align (line 323) | const fn cmsghdr_align(length: usize) -> usize {
  function cmsgdata_align (line 327) | fn cmsgdata_align(length: usize) -> usize {
  function cmsg_data_len (line 331) | fn cmsg_data_len(len: usize) -> usize {
  function cmsg_space (line 335) | fn cmsg_space(len: usize) -> usize {
  function first_cmsg (line 341) | unsafe fn first_cmsg(msg: &mut WinSock::WSAMSG) -> *mut WinSock::CMSGHDR {
  function next_cmsg (line 349) | fn next_cmsg(msg: &WinSock::WSAMSG, cmsg: &WinSock::CMSGHDR) -> *mut Win...
  function cmsg_data (line 359) | fn cmsg_data(cmsg: &mut WinSock::CMSGHDR) -> *mut libc::c_uchar {
  function setsockopt (line 363) | fn setsockopt(io: SOCKET, level: libc::c_int, name: libc::c_int, value: ...
  function wsarecvmsg_ptr (line 375) | fn wsarecvmsg_ptr() -> &'static WinSock::LPFN_WSARECVMSG {