h3x 0.2.0

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

//! 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
//! - [`ReadStreamClient`] — RTC client for a remote readable QUIC stream
//! - [`WriteStreamClient`] — RTC client 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`]
//! - [`ReadStreamClient::into_quic`] — convert into a `quic::ReadStream`
//! - [`ReadStreamClient::into_boxed_quic`] — convert into a boxed reader adapter
//! - [`WriteStreamClient::into_quic`] — convert into a `quic::WriteStream`
//! - [`WriteStreamClient::into_boxed_quic`] — convert into a boxed writer adapter

mod agent;
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::{
    agent::{
        CachedLocalAgent, CachedRemoteAgent, LocalAgentClient, LocalAgentReqReceiver,
        LocalAgentServer, LocalAgentServerRef, LocalAgentServerRefMut, LocalAgentServerShared,
        LocalAgentServerSharedMut, RemoteAgentClient, RemoteAgentReqReceiver, RemoteAgentServer,
        RemoteAgentServerRef, RemoteAgentServerRefMut, RemoteAgentServerShared,
        RemoteAgentServerSharedMut,
    },
    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::{
        ReadStreamClient, ReadStreamReqReceiver, ReadStreamServer, ReadStreamServerRefMut,
        ReadStreamServerSharedMut, WriteStreamClient, WriteStreamReqReceiver, WriteStreamServer,
        WriteStreamServerRefMut, WriteStreamServerSharedMut,
    },
};