h3x 0.6.1

Peer-to-peer DHTTP/3 transport over QUIC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//! Remote forwarding of `quic` traits via RPC RTC.
//!
//! This module exposes raw RTC client and server constructor
//! families as the public API for the QUIC bridge.
//! The current RPC runtime implementation is backed by `remoc`.
//!
//! Any type implementing [`quic::Connection`] automatically implements the RTC
//! [`Connection`] trait via a blanket impl. On the client side,
//! [`RemoteConnection`] wraps a [`ConnectionClient`] and implements
//! [`quic::Connection`] so that remote connections can be used transparently
//! with the h3x protocol stack.
//!
//! The same blanket-plus-wrapper pattern applies to [`Connect`]/[`RemoteConnector`]
//! and [`Listen`]/[`RemoteListener`].
//!
//! # Public API
//!
//! ## Raw RTC client handles
//!
//! These are serializable RPC client types. They are sent over
//! the wire and used to make RPC calls to the remote side.
//!
//! - [`ConnectionClient`] — RTC client for a remote QUIC connection
//! - [`ReadFrameChannels`] — typed frame channels for a remote readable QUIC stream
//! - [`WriteFrameChannels`] — typed frame channels for a remote writable QUIC stream
//! - [`ConnectClient`] — RTC client for a remote QUIC connector
//! - [`ListenClient`] — RTC client for a remote QUIC listener
//!
//! ## Client-side wrappers
//!
//! - [`RemoteConnection`] — wraps [`ConnectionClient`], implements [`quic::Connection`]
//! - [`RemoteConnector`] — wraps [`ConnectClient`], implements [`quic::Connect`]
//! - [`RemoteListener`] — wraps [`ListenClient`], implements [`quic::Listen`]
//!
//! ## Conversion methods
//!
//! - [`ConnectionClient::into_quic`] — convert into a [`RemoteConnection`]
//! - [`ConnectClient::into_quic`] — convert into a [`RemoteConnector`]
//! - [`ListenClient::into_quic`] — convert into a [`RemoteListener`]

mod authority;
mod connect;
mod connection;
mod error;
mod listen;
pub(crate) mod serde_types;
mod stream;

// Raw remoc-generated RTC client types (serializable, sendable over the wire)
pub use self::{
    authority::{
        CachedLocalAuthority, CachedRemoteAuthority, LocalAuthorityClient,
        LocalAuthorityReqReceiver, LocalAuthorityServer, LocalAuthorityServerRef,
        LocalAuthorityServerRefMut, LocalAuthorityServerShared, LocalAuthorityServerSharedMut,
        RemoteAuthorityClient, RemoteAuthorityReqReceiver, RemoteAuthorityServer,
        RemoteAuthorityServerRef, RemoteAuthorityServerRefMut, RemoteAuthorityServerShared,
        RemoteAuthorityServerSharedMut,
    },
    connect::{
        ConnectClient, ConnectError, ConnectReqReceiver, ConnectServer, ConnectServerRef,
        ConnectServerRefMut, ConnectServerShared, ConnectServerSharedMut, RemoteConnector,
    },
    connection::{
        ConnectionClient, ConnectionReqReceiver, ConnectionServer, ConnectionServerRef,
        ConnectionServerRefMut, ConnectionServerShared, ConnectionServerSharedMut,
        RemoteConnection,
    },
    listen::{
        ListenClient, ListenError, ListenReqReceiver, ListenServer, ListenServerRefMut,
        ListenServerSharedMut, RemoteListener,
    },
    stream::{ReadFrameChannels, WriteFrameChannels},
};