Struct ConnectionTable 

pub struct ConnectionTable<T>
where
    T: Clone,
{ /* private fields */ }

A connection table that provides lock-free reads via ArcSwap.

Concurrency design:

• Hot read path (get, for_each, len, is_empty): lock-free via ArcSwap::load(). A single atomic pointer load gives callers an immutable snapshot of the pool.
• Write path (insert, insert_at, remove): serialised by write_lock. Writers load the current snapshot, clone the pool, apply the change, then atomically store the new Arc. No write lock is ever held during reads.

Connections are stored as Arc<T> so that pool clones (made on every write) only bump refcounts rather than deep-copying each connection. get() returns Option<Arc<T>>; callers can auto-deref into T.

Implementations

impl<T> ConnectionTable<T>

where T: Clone,

pub fn with_capacity(capacity: usize) -> Self

Create a new connection table with a given capacity

pub fn insert(&self, connection: T) -> u64

Add a connection to the table, returning its stable ID.

pub fn insert_at(&self, connection: T, id: u64)

Add a connection at a specific ID.

pub fn remove(&self, id: u64) -> bool

Remove the connection with the given ID.

pub fn len(&self) -> usize

Number of connections in the table.

pub fn capacity(&self) -> usize

Current allocated capacity.

pub fn is_empty(&self) -> bool

Returns true if the table contains no connections.

pub fn get(&self, id: u64) -> Option<Arc<T>>

Look up a connection by its stable ID.

pub fn for_each<F>(&self, f: F)

where F: FnMut(u64, Arc<T>),

Call f(id, connection) for every live connection.

pub fn update<F>(&self, id: u64, f: F) -> bool

where F: FnOnce(&mut T),

Mutate a connection in-place (copy-on-write).

Clones the pool, applies f to the entry, and replaces the pool atomically. Returns true if the connection was found and updated.

Trait Implementations

impl<T> Debug for ConnectionTable<T>

where T: Clone + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.