SYMBOL INDEX (386 symbols across 23 files)

FILE: src/bandwidth_limiter.rs
  type BandwidthLimiter (line 5) | pub struct BandwidthLimiter<T: Timer> {
  function new (line 14) | pub fn new(timer: &T, bandwidth: u32, burst_bandwidth: u32) -> Self {
  function delay_until_available (line 25) | pub fn delay_until_available(&self, timer: &T) -> Option<T::Sleep> {
  function update_available (line 37) | pub fn update_available(&mut self, timer: &T) {
  function bytes_available (line 51) | pub fn bytes_available(&self) -> bool {
  function take_bytes (line 56) | pub fn take_bytes(&mut self, bytes: u32) {

FILE: src/buffer.rs
  type BufferPool (line 7) | pub trait BufferPool {
    method capacity (line 10) | fn capacity(&self) -> usize;
    method acquire (line 11) | fn acquire(&mut self) -> Self::Buffer;
  type BufferPacketPool (line 16) | pub struct BufferPacketPool<B>(B);
  function new (line 19) | pub fn new(buffer_pool: B) -> Self {
  type Packet (line 25) | type Packet = BufferPacket<B::Buffer>;
  method capacity (line 27) | fn capacity(&self) -> usize {
  method acquire (line 31) | fn acquire(&mut self) -> Self::Packet {
  type BufferPacket (line 40) | pub struct BufferPacket<B> {
  method resize (line 49) | fn resize(&mut self, len: usize, val: u8) {
  type Target (line 62) | type Target = [u8];
  method deref (line 64) | fn deref(&self) -> &[u8] {
  method deref_mut (line 73) | fn deref_mut(&mut self) -> &mut [u8] {

FILE: src/compressed_bincode_channel.rs
  constant MAX_MESSAGE_LEN (line 20) | pub const MAX_MESSAGE_LEN: u16 = u16::MAX;
  type SendError (line 23) | pub enum SendError {
  type RecvError (line 33) | pub enum RecvError {
  type CompressedBincodeChannel (line 55) | pub struct CompressedBincodeChannel {
    method from (line 74) | fn from(channel: ReliableChannel) -> Self {
    method new (line 80) | pub fn new(channel: ReliableChannel) -> Self {
    method into_inner (line 95) | pub fn into_inner(self) -> ReliableChannel {
    method send (line 103) | pub async fn send<M: Serialize>(&mut self, msg: &M) -> Result<(), Send...
    method try_send (line 107) | pub fn try_send<M: Serialize>(&mut self, msg: &M) -> Result<bool, Send...
    method flush (line 119) | pub async fn flush(&mut self) -> Result<(), reliable_channel::Error> {
    method try_flush (line 123) | pub fn try_flush(&mut self) -> Result<bool, reliable_channel::Error> {
    method recv (line 135) | pub async fn recv<M: DeserializeOwned>(&mut self) -> Result<M, RecvErr...
    method try_recv (line 140) | pub fn try_recv<M: DeserializeOwned>(&mut self) -> Result<Option<M>, R...
    method poll_send (line 148) | pub fn poll_send<M: Serialize>(
    method poll_flush (line 165) | pub fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), reli...
    method poll_recv (line 172) | pub fn poll_recv<M: DeserializeOwned>(
    method poll_recv_ready (line 180) | fn poll_recv_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Rec...
    method recv_next (line 212) | fn recv_next<M: DeserializeOwned>(&mut self) -> Result<M, bincode::Err...
    method poll_write_send_chunk (line 220) | fn poll_write_send_chunk(
    method poll_finish_write (line 262) | fn poll_finish_write(&mut self, cx: &mut Context) -> Poll<Result<(), r...
    method poll_finish_read (line 272) | fn poll_finish_read(&mut self, cx: &mut Context) -> Poll<Result<(), re...
    method bincode_config (line 282) | fn bincode_config(&self) -> impl bincode::Options + Copy {
  type CompressedTypedChannel (line 288) | pub struct CompressedTypedChannel<M> {
  function from (line 294) | fn from(channel: ReliableChannel) -> Self {
  function new (line 300) | pub fn new(channel: ReliableChannel) -> Self {
  function into_inner (line 307) | pub fn into_inner(self) -> ReliableChannel {
  function flush (line 311) | pub async fn flush(&mut self) -> Result<(), reliable_channel::Error> {
  function try_flush (line 315) | pub fn try_flush(&mut self) -> Result<bool, reliable_channel::Error> {
  function poll_flush (line 319) | pub fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), reliab...
  function send (line 325) | pub async fn send(&mut self, msg: &M) -> Result<(), SendError> {
  function try_send (line 329) | pub fn try_send(&mut self, msg: &M) -> Result<bool, SendError> {
  function poll_send (line 333) | pub fn poll_send(&mut self, cx: &mut Context, msg: &M) -> Poll<Result<()...
  function recv (line 339) | pub async fn recv(&mut self) -> Result<M, RecvError> {
  function try_recv (line 343) | pub fn try_recv(&mut self) -> Result<Option<M>, RecvError> {
  function poll_recv (line 347) | pub fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<M, RecvErro...

FILE: src/event_watch.rs
  function channel (line 27) | pub fn channel() -> (Sender, Receiver) {
  type Sender (line 39) | pub struct Sender(Arc<State>);
    method signal (line 42) | pub fn signal(&self) {
  type Receiver (line 49) | pub struct Receiver(Arc<State>);
    method wait (line 52) | pub async fn wait(&mut self) {
  type State (line 70) | struct State {

FILE: src/message_channels.rs
  type MessageChannelSettings (line 33) | pub struct MessageChannelSettings {
  type MessageChannelMode (line 45) | pub enum MessageChannelMode {
  type ChannelMessage (line 51) | pub trait ChannelMessage: Serialize + DeserializeOwned + Send + Sync + '...
  type ChannelAlreadyRegistered (line 56) | pub enum ChannelAlreadyRegistered {
  type TaskError (line 63) | pub type TaskError = Box<dyn Error + Send + Sync>;
  type ChannelTaskError (line 67) | pub struct ChannelTaskError {
  type MessageChannelsBuilder (line 72) | pub struct MessageChannelsBuilder<S, T, P>
  function new (line 91) | pub fn new(spawn: S, timer: T, pool: P) -> Self {
  function register (line 114) | pub fn register<M: ChannelMessage>(
  function build (line 137) | pub fn build(self, multiplexer: &mut PacketMultiplexer<P::Packet>) -> Me...
  type MessageTypeUnregistered (line 184) | pub struct MessageTypeUnregistered(&'static str);
  type MessageChannelsDisconnected (line 188) | pub struct MessageChannelsDisconnected;
  type TryAsyncMessageError (line 191) | pub enum TryAsyncMessageError {
  type MessageChannels (line 209) | pub struct MessageChannels {
    method is_connected (line 221) | pub fn is_connected(&self) -> bool {
    method recv_err (line 230) | pub async fn recv_err(self) -> ChannelTaskError {
    method send (line 247) | pub fn send<M: ChannelMessage>(&mut self, message: M) -> Option<M> {
    method try_send (line 253) | pub fn try_send<M: ChannelMessage>(
    method async_send (line 281) | pub async fn async_send<M: ChannelMessage>(
    method try_async_send (line 293) | pub async fn try_async_send<M: ChannelMessage>(
    method flush (line 319) | pub fn flush<M: ChannelMessage>(&mut self) {
    method try_flush (line 325) | pub fn try_flush<M: ChannelMessage>(&mut self) -> Result<(), MessageTy...
    method recv (line 336) | pub fn recv<M: ChannelMessage>(&mut self) -> Option<M> {
    method try_recv (line 342) | pub fn try_recv<M: ChannelMessage>(&mut self) -> Result<Option<M>, Mes...
    method async_recv (line 368) | pub async fn async_recv<M: ChannelMessage>(
    method try_async_recv (line 379) | pub async fn try_async_recv<M: ChannelMessage>(&mut self) -> Result<M,...
    method statistics (line 392) | pub fn statistics<M: ChannelMessage>(&self) -> &ChannelStatistics {
    method try_statistics (line 396) | pub fn try_statistics<M: ChannelMessage>(
  type ChannelTask (line 403) | type ChannelTask = BoxFuture<'static, Result<(), TaskError>>;
  type RegisterFn (line 404) | type RegisterFn<S, T, P> = fn(
  type ChannelDisconnected (line 415) | struct ChannelDisconnected;
  type ChannelSet (line 417) | struct ChannelSet<M> {
  type ChannelsMap (line 425) | struct ChannelsMap(FxHashMap<TypeId, Box<dyn Any + Send + Sync>>);
    method insert (line 428) | fn insert<M: ChannelMessage>(&mut self, channel_set: ChannelSet<M>) ->...
    method get (line 434) | fn get<M: ChannelMessage>(&self) -> Result<&ChannelSet<M>, MessageType...
    method get_mut (line 443) | fn get_mut<M: ChannelMessage>(
  function register_message_type (line 455) | fn register_message_type<S, T, P, M>(
  type MessageBincodeChannel (line 535) | trait MessageBincodeChannel<M: ChannelMessage> {
    method poll_recv (line 536) | fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<M, TaskError>>;
    method poll_send (line 537) | fn poll_send(&mut self, cx: &mut Context, msg: &M) -> Poll<Result<(), ...
    method poll_flush (line 538) | fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), TaskErro...
  function poll_recv (line 547) | fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<M, TaskError>> {
  function poll_send (line 551) | fn poll_send(&mut self, cx: &mut Context, msg: &M) -> Poll<Result<(), Ta...
  function poll_flush (line 556) | fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), TaskError>> {
  function poll_recv (line 562) | fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<M, TaskError>> {
  function poll_send (line 566) | fn poll_send(&mut self, cx: &mut Context, msg: &M) -> Poll<Result<(), Ta...
  function poll_flush (line 571) | fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), TaskError>> {
  function poll_recv (line 577) | fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<M, TaskError>> {
  function poll_send (line 581) | fn poll_send(&mut self, cx: &mut Context, msg: &M) -> Poll<Result<(), Ta...
  function poll_flush (line 585) | fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), TaskError>> {
  function channel_task (line 590) | async fn channel_task<M: ChannelMessage>(

FILE: src/packet.rs
  constant MAX_PACKET_LEN (line 7) | pub const MAX_PACKET_LEN: u16 = 32768;
  type Packet (line 10) | pub trait Packet: Deref<Target = [u8]> + DerefMut {
    method resize (line 12) | fn resize(&mut self, len: usize, val: u8);
    method extend (line 14) | fn extend(&mut self, other: &[u8]) {
    method truncate (line 21) | fn truncate(&mut self, len: usize) {
    method clear (line 26) | fn clear(&mut self) {
  type PacketPool (line 37) | pub trait PacketPool {
    method capacity (line 41) | fn capacity(&self) -> usize;
    method acquire (line 43) | fn acquire(&mut self) -> Self::Packet;

FILE: src/packet_multiplexer.rs
  type PacketChannel (line 23) | pub type PacketChannel = u8;
  type MuxPacket (line 27) | pub struct MuxPacket<P>(P);
  method resize (line 33) | fn resize(&mut self, len: usize, val: u8) {
  method extend (line 37) | fn extend(&mut self, other: &[u8]) {
  method truncate (line 41) | fn truncate(&mut self, len: usize) {
  method clear (line 45) | fn clear(&mut self) {
  type Target (line 54) | type Target = [u8];
  method deref (line 56) | fn deref(&self) -> &[u8] {
  method deref_mut (line 65) | fn deref_mut(&mut self) -> &mut [u8] {
  type MuxPacketPool (line 71) | pub struct MuxPacketPool<P>(P);
  function new (line 74) | pub fn new(packet_pool: P) -> Self {
  type Packet (line 83) | type Packet = MuxPacket<P::Packet>;
  method capacity (line 85) | fn capacity(&self) -> usize {
  method acquire (line 89) | fn acquire(&mut self) -> MuxPacket<P::Packet> {
  function from (line 97) | fn from(pool: P) -> MuxPacketPool<P> {
  type DuplicateChannel (line 104) | pub struct DuplicateChannel;
  type ChannelTotals (line 107) | pub struct ChannelTotals {
  type ChannelStatistics (line 113) | pub struct ChannelStatistics(Arc<ChannelStatisticsData>);
    method incoming_totals (line 116) | pub fn incoming_totals(&self) -> ChannelTotals {
    method outgoing_totals (line 123) | pub fn outgoing_totals(&self) -> ChannelTotals {
  type PacketMultiplexer (line 136) | pub struct PacketMultiplexer<P> {
  function new (line 145) | pub fn new() -> PacketMultiplexer<P> {
  function open_channel (line 157) | pub fn open_channel(
  function start (line 197) | pub fn start(self) -> (IncomingMultiplexedPackets<P>, OutgoingMultiplexe...
  type IncomingError (line 212) | pub enum IncomingError {
  type IncomingTrySendError (line 220) | pub enum IncomingTrySendError<P> {
  function fmt (line 228) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function is_full (line 240) | pub fn is_full(&self) -> bool {
  type IncomingMultiplexedPackets (line 249) | pub struct IncomingMultiplexedPackets<P> {
  function try_send (line 265) | pub fn try_send(&mut self, packet: P) -> Result<(), IncomingTrySendError...
  type Error (line 290) | type Error = IncomingError;
  function poll_ready (line 292) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result...
  function start_send (line 321) | fn start_send(mut self: Pin<&mut Self>, item: P) -> Result<(), Self::Err...
  function poll_flush (line 327) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result...
  function poll_close (line 349) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(),...
  type OutgoingMultiplexedPackets (line 355) | pub struct OutgoingMultiplexedPackets<P> {
  type Item (line 363) | type Item = P;
  method poll_next (line 365) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<...
  type ChannelSender (line 370) | struct ChannelSender<P> {
  type ChannelReceiver (line 375) | struct ChannelReceiver<P> {
  type Item (line 387) | type Item = P;
  method poll_next (line 389) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<...
  type ChannelStatisticsData (line 405) | struct ChannelStatisticsData {
    method mark_incoming_packet (line 414) | fn mark_incoming_packet(&self, len: u64) {
    method mark_outgoing_packet (line 419) | fn mark_outgoing_packet(&self, len: u64) {

FILE: src/reliable_bincode_channel.rs
  constant MAX_MESSAGE_LEN (line 16) | pub const MAX_MESSAGE_LEN: u16 = u16::MAX;
  type SendError (line 19) | pub enum SendError {
  type RecvError (line 29) | pub enum RecvError {
  type ReliableBincodeChannel (line 43) | pub struct ReliableBincodeChannel {
    method from (line 54) | fn from(channel: ReliableChannel) -> Self {
    method new (line 61) | pub fn new(channel: ReliableChannel) -> Self {
    method into_inner (line 71) | pub fn into_inner(self) -> ReliableChannel {
    method send (line 83) | pub async fn send<M: Serialize>(&mut self, msg: &M) -> Result<(), Send...
    method try_send (line 89) | pub fn try_send<M: Serialize>(&mut self, msg: &M) -> Result<bool, Send...
    method flush (line 101) | pub async fn flush(&mut self) -> Result<(), reliable_channel::Error> {
    method try_flush (line 105) | pub fn try_flush(&mut self) -> Result<bool, reliable_channel::Error> {
    method recv (line 117) | pub async fn recv<'a, M: Deserialize<'a>>(&'a mut self) -> Result<M, R...
    method try_recv (line 122) | pub fn try_recv<'a, M: Deserialize<'a>>(&'a mut self) -> Result<Option...
    method poll_send_ready (line 130) | pub fn poll_send_ready(
    method try_send_ready (line 147) | pub fn try_send_ready(&mut self) -> Result<bool, reliable_channel::Err...
    method start_send (line 155) | pub fn start_send<M: Serialize>(&mut self, msg: &M) -> Result<(), binc...
    method poll_flush (line 168) | pub fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), reli...
    method poll_recv (line 174) | pub fn poll_recv<'a, M: Deserialize<'a>>(
    method poll_recv_ready (line 182) | fn poll_recv_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Rec...
    method recv_next (line 195) | fn recv_next<'a, M: Deserialize<'a>>(&'a mut self) -> Result<M, RecvEr...
    method poll_finish_read (line 202) | fn poll_finish_read(&mut self, cx: &mut Context) -> Poll<Result<(), re...
    method bincode_config (line 212) | fn bincode_config(&self) -> impl bincode::Options + Copy {
  type ReliableTypedChannel (line 218) | pub struct ReliableTypedChannel<M> {
  function from (line 224) | fn from(channel: ReliableChannel) -> Self {
  function new (line 230) | pub fn new(channel: ReliableChannel) -> Self {
  function into_inner (line 237) | pub fn into_inner(self) -> ReliableChannel {
  function flush (line 241) | pub async fn flush(&mut self) -> Result<(), reliable_channel::Error> {
  function try_flush (line 245) | pub fn try_flush(&mut self) -> Result<bool, reliable_channel::Error> {
  function poll_flush (line 249) | pub fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), reliab...
  function poll_send_ready (line 253) | pub fn poll_send_ready(
  function try_send_ready (line 260) | pub fn try_send_ready(&mut self) -> Result<bool, reliable_channel::Error> {
  function send (line 266) | pub async fn send(&mut self, msg: &M) -> Result<(), SendError> {
  function try_send (line 270) | pub fn try_send(&mut self, msg: &M) -> Result<bool, SendError> {
  function start_send (line 274) | pub fn start_send(&mut self, msg: &M) -> Result<(), bincode::Error> {
  function recv (line 280) | pub async fn recv(&'a mut self) -> Result<M, RecvError> {
  function try_recv (line 284) | pub fn try_recv(&'a mut self) -> Result<Option<M>, RecvError> {
  function poll_recv (line 288) | pub fn poll_recv(&'a mut self, cx: &mut Context) -> Poll<Result<M, RecvE...

FILE: src/reliable_channel.rs
  type Error (line 34) | pub enum Error {
  type Settings (line 44) | pub struct Settings {
  type ReliableChannel (line 79) | pub struct ReliableChannel {
    method new (line 87) | pub fn new<S, T, P>(
    method write (line 159) | pub async fn write(&mut self, data: &[u8]) -> Result<usize, Error> {
    method flush (line 167) | pub fn flush(&mut self) -> Result<(), Error> {
    method read (line 182) | pub async fn read(&mut self, data: &mut [u8]) -> Result<usize, Error> {
    method poll_write (line 186) | pub fn poll_write(&mut self, cx: &mut Context, data: &[u8]) -> Poll<Re...
    method poll_read (line 214) | pub fn poll_read(&mut self, cx: &mut Context, data: &mut [u8]) -> Poll...
    method write_available (line 242) | pub fn write_available(&self) -> usize {
    method try_write (line 247) | pub fn try_write(&mut self, data: &[u8]) -> Result<usize, Error> {
    method try_read (line 256) | pub fn try_read(&mut self, data: &mut [u8]) -> Result<usize, Error> {
  type Shared (line 266) | struct Shared {
  type UnackedRange (line 272) | struct UnackedRange<I> {
  type Task (line 279) | struct Task<T, P>
  function main_loop (line 305) | async fn main_loop(mut self) -> Result<(), Error> {
  function send (line 402) | async fn send(&mut self) -> Result<(), Error> {
  function resend (line 448) | async fn resend(&mut self) -> Result<(), Error> {
  function recv_packet (line 489) | async fn recv_packet(&mut self, packet: P::Packet) -> Result<(), Error> {

FILE: src/ring_buffer.rs
  type RingBuffer (line 14) | pub struct RingBuffer {
    method new (line 22) | pub fn new(capacity: usize) -> (Writer, Reader) {
    method write_available (line 40) | pub fn write_available(&self) -> usize {
    method read_available (line 47) | pub fn read_available(&self) -> usize {
  method drop (line 56) | fn drop(&mut self) {
  type Writer (line 69) | pub struct Writer(Arc<RingBuffer>);
    method available (line 72) | pub fn available(&self) -> usize {
    method write (line 76) | pub fn write(&mut self, mut offset: usize, mut data: &[u8]) -> usize {
    method advance (line 121) | pub fn advance(&mut self, offset: usize) -> usize {
    method buffer (line 132) | pub fn buffer(&self) -> &RingBuffer {
  type Reader (line 137) | pub struct Reader(Arc<RingBuffer>);
    method available (line 140) | pub fn available(&self) -> usize {
    method read (line 144) | pub fn read(&self, mut offset: usize, mut data: &mut [u8]) -> usize {
    method advance (line 189) | pub fn advance(&mut self, offset: usize) -> usize {
    method buffer (line 200) | pub fn buffer(&self) -> &RingBuffer {
  function collapse_position (line 205) | fn collapse_position(capacity: usize, pos: usize) -> usize {
  function tail_to_head (line 213) | fn tail_to_head(capacity: usize, tail: usize, head: usize) -> usize {
  function head_to_tail (line 221) | fn head_to_tail(capacity: usize, head: usize, tail: usize) -> usize {
  function increment (line 225) | fn increment(capacity: usize, pos: usize, n: usize) -> usize {
  function write_slice (line 238) | fn write_slice(dst: &mut [MaybeUninit<u8>], src: &[u8]) {
  function basic_read_write (line 250) | fn basic_read_write() {
  function threaded_read_write (line 308) | fn threaded_read_write() {

FILE: src/runtime.rs
  type Spawn (line 7) | pub trait Spawn: Send + Sync {
    method spawn (line 8) | fn spawn<F>(&self, future: F)
  type Timer (line 15) | pub trait Timer: Send + Sync {
    method now (line 20) | fn now(&self) -> Self::Instant;
    method duration_between (line 24) | fn duration_between(&self, earlier: Self::Instant, later: Self::Instan...
    method sleep (line 27) | fn sleep(&self, duration: Duration) -> Self::Sleep;

FILE: src/spsc.rs
  type Shared (line 12) | struct Shared {
  type Receiver (line 17) | pub struct Receiver<T> {
  method drop (line 23) | fn drop(&mut self) {
  type Item (line 31) | type Item = T;
  method poll_next (line 33) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<...
  function try_recv (line 50) | pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
  type Disconnected (line 59) | pub struct Disconnected;
  type Sender (line 61) | pub struct Sender<T> {
  method drop (line 68) | fn drop(&mut self) {
  type Error (line 76) | type Error = Disconnected;
  function poll_ready (line 78) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result...
  function start_send (line 100) | fn start_send(mut self: Pin<&mut Self>, item: T) -> Result<(), Self::Err...
  function poll_flush (line 107) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(),...
  function poll_close (line 111) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(),...
  function try_send (line 117) | pub fn try_send(&mut self, t: T) -> Result<(), TrySendError<T>> {
  function channel (line 140) | pub fn channel<T>(capacity: usize) -> (Sender<T>, Receiver<T>) {

FILE: src/unreliable_bincode_channel.rs
  type SendError (line 18) | pub enum SendError {
  type RecvError (line 27) | pub enum RecvError {
  type UnreliableBincodeChannel (line 40) | pub struct UnreliableBincodeChannel<T, P>
  function from (line 54) | fn from(channel: UnreliableChannel<T, P>) -> Self {
  function new (line 64) | pub fn new(channel: UnreliableChannel<T, P>) -> Self {
  function into_inner (line 71) | pub fn into_inner(self) -> UnreliableChannel<T, P> {
  function max_message_len (line 78) | pub fn max_message_len(&self) -> u16 {
  function send (line 89) | pub async fn send<M: Serialize>(&mut self, msg: &M) -> Result<(), SendEr...
  function try_send (line 95) | pub fn try_send<M: Serialize>(&mut self, msg: &M) -> Result<bool, SendEr...
  function flush (line 110) | pub async fn flush(&mut self) -> Result<(), unreliable_channel::SendErro...
  function try_flush (line 114) | pub fn try_flush(&mut self) -> Result<bool, unreliable_channel::SendErro...
  function recv (line 126) | pub async fn recv<'a, M: Deserialize<'a>>(&'a mut self) -> Result<M, Rec...
  function try_recv (line 132) | pub fn try_recv<'a, M: Deserialize<'a>>(&'a mut self) -> Result<Option<M...
  function poll_send_ready (line 140) | pub fn poll_send_ready(
  function try_send_ready (line 151) | pub fn try_send_ready(&mut self) -> Result<bool, unreliable_channel::Sen...
  function start_send (line 159) | pub fn start_send<M: Serialize>(&mut self, msg: &M) -> Result<(), bincod...
  function poll_flush (line 168) | pub fn poll_flush(
  function poll_recv (line 177) | pub fn poll_recv<'a, M: Deserialize<'a>>(
  function bincode_config (line 186) | fn bincode_config(&self) -> impl bincode::Options + Copy {
  type UnreliableTypedChannel (line 192) | pub struct UnreliableTypedChannel<T, P, M>
  function from (line 206) | fn from(channel: UnreliableChannel<T, P>) -> Self {
  function new (line 216) | pub fn new(channel: UnreliableChannel<T, P>) -> Self {
  function into_inner (line 223) | pub fn into_inner(self) -> UnreliableChannel<T, P> {
  function flush (line 227) | pub async fn flush(&mut self) -> Result<(), unreliable_channel::SendErro...
  function try_flush (line 231) | pub fn try_flush(&mut self) -> Result<bool, unreliable_channel::SendErro...
  function poll_flush (line 235) | pub fn poll_flush(
  function poll_send_ready (line 242) | pub fn poll_send_ready(
  function try_send_ready (line 249) | pub fn try_send_ready(&mut self) -> Result<bool, unreliable_channel::Sen...
  function send (line 260) | pub async fn send(&mut self, msg: &M) -> Result<(), SendError> {
  function try_send (line 264) | pub fn try_send(&mut self, msg: &M) -> Result<bool, SendError> {
  function start_send (line 268) | pub fn start_send(&mut self, msg: &M) -> Result<(), bincode::Error> {
  function recv (line 279) | pub async fn recv(&'a mut self) -> Result<M, RecvError> {
  function try_recv (line 283) | pub fn try_recv(&'a mut self) -> Result<Option<M>, RecvError> {
  function poll_recv (line 287) | pub fn poll_recv(&'a mut self, cx: &mut Context) -> Poll<Result<M, RecvE...

FILE: src/unreliable_channel.rs
  type Disconnected (line 23) | pub struct Disconnected;
  type SendError (line 26) | pub enum SendError {
  type RecvError (line 35) | pub enum RecvError {
  type Settings (line 44) | pub struct Settings {
  type UnreliableChannel (line 53) | pub struct UnreliableChannel<T, P>
  function new (line 73) | pub fn new(
  function max_message_len (line 98) | pub fn max_message_len(&self) -> u16 {
  function send (line 113) | pub async fn send(&mut self, msg: &[u8]) -> Result<(), SendError> {
  function try_send (line 117) | pub fn try_send(&mut self, msg: &[u8]) -> Result<bool, SendError> {
  function flush (line 131) | pub async fn flush(&mut self) -> Result<(), Disconnected> {
  function try_flush (line 135) | pub fn try_flush(&mut self) -> Result<bool, Disconnected> {
  function recv (line 150) | pub async fn recv(&mut self) -> Result<&[u8], RecvError> {
  function try_recv (line 155) | pub fn try_recv(&mut self) -> Result<Option<&[u8]>, RecvError> {
  function poll_send (line 163) | pub fn poll_send(&mut self, cx: &mut Context, msg: &[u8]) -> Poll<Result...
  function poll_send_ready (line 175) | pub fn poll_send_ready(
  function start_send (line 198) | pub fn start_send(&mut self) -> StartSend<P::Packet> {
  function poll_flush (line 202) | pub fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), Discon...
  function poll_recv (line 230) | pub fn poll_recv(&mut self, cx: &mut Context) -> Poll<Result<&[u8], Recv...
  function poll_recv_ready (line 235) | fn poll_recv_ready(&mut self, cx: &mut Context) -> Poll<Result<(), RecvE...
  function recv_next (line 250) | fn recv_next(&mut self) -> Result<&[u8], RecvError> {
  type StartSend (line 273) | pub struct StartSend<'a, P> {
  function new (line 280) | fn new(packet: &'a mut P, capacity: usize) -> Self {
  function buffer (line 295) | pub fn buffer(&mut self) -> &mut [u8] {
  function finish (line 303) | pub fn finish(self, msg_len: usize) {

FILE: src/windows.rs
  type StreamPos (line 5) | pub type StreamPos = Wrapping<u32>;
  function stream_cmp (line 18) | pub fn stream_cmp(a: StreamPos, b: StreamPos) -> Option<Ordering> {
  function stream_lt (line 27) | pub fn stream_lt(a: StreamPos, b: StreamPos) -> bool {
  function stream_le (line 31) | pub fn stream_le(a: StreamPos, b: StreamPos) -> bool {
  function stream_gt (line 35) | pub fn stream_gt(a: StreamPos, b: StreamPos) -> bool {
  function stream_ge (line 39) | pub fn stream_ge(a: StreamPos, b: StreamPos) -> bool {
  type AckResult (line 44) | pub enum AckResult {
  type SendWindowWriter (line 54) | pub struct SendWindowWriter {
    method write (line 61) | pub fn write(&mut self, data: &[u8]) -> u32 {
    method write_available (line 68) | pub fn write_available(&self) -> u32 {
  type SendWindow (line 75) | pub struct SendWindow {
    method new (line 89) | pub fn new(capacity: u32, stream_start: StreamPos) -> (SendWindow, Sen...
    method write_available (line 106) | pub fn write_available(&self) -> u32 {
    method send_pos (line 112) | pub fn send_pos(&self) -> StreamPos {
    method send_available (line 116) | pub fn send_available(&self) -> u32 {
    method send (line 127) | pub fn send(&mut self, data: &mut [u8]) -> Option<(StreamPos, StreamPo...
    method unacked_start (line 151) | pub fn unacked_start(&self) -> StreamPos {
    method get_unacked (line 157) | pub fn get_unacked(&self, start: StreamPos, data: &mut [u8]) {
    method ack_range (line 169) | pub fn ack_range(&mut self, start: StreamPos, end: StreamPos) -> AckRe...
  type RecvWindowReader (line 226) | pub struct RecvWindowReader {
    method read (line 233) | pub fn read(&mut self, data: &mut [u8]) -> u32 {
  type RecvWindow (line 242) | pub struct RecvWindow {
    method new (line 261) | pub fn new(capacity: u32, stream_start: StreamPos) -> (RecvWindow, Rec...
    method read_available (line 277) | pub fn read_available(&self) -> u32 {
    method window_end (line 283) | pub fn window_end(&self) -> StreamPos {
    method recv (line 304) | pub fn recv(&mut self, start_pos: StreamPos, data: &[u8]) -> Option<St...
  function test_send_window (line 452) | fn test_send_window() {
  function test_recv_window (line 581) | fn test_recv_window() {

FILE: tests/compressed_bincode_channel.rs
  function test_compressed_bincode_channel (line 19) | fn test_compressed_bincode_channel() {

FILE: tests/message_channels.rs
  type Message1 (line 28) | struct Message1(i32);
  constant MESSAGE1_SETTINGS (line 30) | const MESSAGE1_SETTINGS: MessageChannelSettings = MessageChannelSettings {
  type Message2 (line 51) | struct Message2(i32);
  constant MESSAGE2_SETTINGS (line 53) | const MESSAGE2_SETTINGS: MessageChannelSettings = MessageChannelSettings {
  function test_message_channels (line 64) | fn test_message_channels() {

FILE: tests/packet_multiplexer.rs
  function test_multiplexer (line 19) | fn test_multiplexer() {

FILE: tests/reliable_bincode_channel.rs
  function test_reliable_bincode_channel (line 19) | fn test_reliable_bincode_channel() {

FILE: tests/reliable_channel.rs
  function test_reliable_stream (line 18) | fn test_reliable_stream() {

FILE: tests/unreliable_bincode_channel.rs
  function test_unreliable_bincode_channel (line 17) | fn test_unreliable_bincode_channel() {

FILE: tests/unreliable_channel.rs
  function test_unreliable_channel (line 15) | fn test_unreliable_channel() {

FILE: tests/util/mod.rs
  type SimpleBufferPool (line 30) | pub struct SimpleBufferPool(pub usize);
  type Buffer (line 33) | type Buffer = Box<[u8]>;
  method capacity (line 35) | fn capacity(&self) -> usize {
  method acquire (line 39) | fn acquire(&mut self) -> Self::Buffer {
  type TimeState (line 44) | struct TimeState {
  type IncomingTasks (line 49) | type IncomingTasks = Mutex<Vec<BoxFuture<'static, ()>>>;
  type HandleInner (line 51) | struct HandleInner {
  type SimpleRuntime (line 56) | pub struct SimpleRuntime {
    method new (line 65) | pub fn new() -> Self {
    method handle (line 78) | pub fn handle(&self) -> SimpleRuntimeHandle {
    method advance_time (line 82) | pub fn advance_time(&mut self, millis: u64) {
    method run_until_stalled (line 100) | pub fn run_until_stalled(&mut self) -> bool {
  type SimpleRuntimeHandle (line 62) | pub struct SimpleRuntimeHandle(Arc<HandleInner>);
  type Target (line 126) | type Target = SimpleRuntimeHandle;
  method deref (line 128) | fn deref(&self) -> &Self::Target {
  function do_delay (line 133) | async fn do_delay(state: Arc<HandleInner>, duration: Duration) -> u64 {
  method spawn (line 154) | fn spawn<F: Future<Output = ()> + Send + 'static>(&self, f: F) {
  type Instant (line 160) | type Instant = u64;
  type Sleep (line 161) | type Sleep = Pin<Box<dyn Future<Output = ()> + Send>>;
  method now (line 163) | fn now(&self) -> Self::Instant {
  method duration_between (line 167) | fn duration_between(&self, earlier: Self::Instant, later: Self::Instant)...
  method sleep (line 171) | fn sleep(&self, duration: Duration) -> Self::Sleep {
  type LinkCondition (line 180) | pub struct LinkCondition {
  function condition_link (line 187) | pub fn condition_link<P>(