Struct SharedReplaceableClient 

pub struct SharedReplaceableClient<C>
where
    C: Clone + Send + Sync,
{ /* private fields */ }

A client wrapper that allows replacing the underlying client at a later point in time. Clones of this struct have a shared reference to the underlying client, and each clone also has its own cached clone of the underlying client. Before every service call, a check is made whether the shared client was replaced, and the cached clone is updated accordingly.

This struct is fully thread-safe, and it works in a lock-free manner except when the client is being replaced. A read-write lock is used then, with minimal locking time.

Implementations

impl<C> SharedReplaceableClient<C>

where C: Clone + Send + Sync,

pub fn new(client: C) -> Self

Creates the initial instance of replaceable client with the provided underlying client. Use clone() method to create more instances that share the same underlying client.

pub fn replace_client(&self, new_client: C)

Replaces the client for all instances that share this instance’s underlying client.

pub fn inner_clone(&self) -> C

Returns a clone of the underlying client.

pub fn inner_cow(&self) -> Cow<'_, C>

Returns an immutable reference to this instance’s cached clone of the underlying client if it’s up to date, or a fresh clone of the shared client otherwise. Because it’s an immutable method, it will not update this instance’s cached clone. For this reason, prefer to use inner_mut_refreshed() when possible.

pub fn inner_mut_refreshed(&mut self) -> &mut C

Returns a mutable reference to this instance’s cached clone of the underlying client. If the cached clone is not up to date, it’s refreshed before the reference is returned. This method is called automatically by most other mutable methods, in particular by all service calls, so most of the time it doesn’t need to be called directly.

While this method allows mutable access to the underlying client, any configuration changes will not be shared with other instances, and will be lost if the client gets replaced from anywhere. To make configuration changes, use replace_client() instead.

Trait Implementations

impl<C> Clone for SharedReplaceableClient<C>

where C: Clone + Send + Sync,

fn clone(&self) -> Self

Creates a new instance of replaceable client that shares the underlying client with this instance. Replacing a client in either instance will replace it for both instances, and all other clones too.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C> Debug for SharedReplaceableClient<C>

where C: Clone + Send + Sync + Debug,

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

Formats the value using the given formatter.

impl<C> NamespacedClient for SharedReplaceableClient<C>

where C: NamespacedClient + Clone + Send + Sync,

fn namespace(&self) -> String

Returns the namespace this client is bound to

fn identity(&self) -> String

Returns the client identity